@sparkleideas/shared 3.0.0-alpha.7

package/__tests__/hooks/file-organization.test.ts

@@ -0,0 +1,335 @@
+/**
+ * V3 File Organization Hook Tests
+ *
+ * Tests for file organization enforcement and formatter recommendations.
+ *
+ * @module v3/shared/hooks/__tests__/file-organization.test
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  createHookRegistry,
+  createFileOrganizationHook,
+  FileOrganizationHook,
+  HookRegistry,
+} from '../../src/hooks/index.js';
+
+describe('FileOrganizationHook', () => {
+  let registry: HookRegistry;
+  let fileOrg: FileOrganizationHook;
+
+  beforeEach(() => {
+    registry = createHookRegistry();
+    fileOrg = createFileOrganizationHook(registry);
+  });
+
+  describe('root folder blocking', () => {
+    it('should block TypeScript source files in root', async () => {
+      const result = await fileOrg.analyze('utils.ts');
+
+      expect(result.blocked).toBe(true);
+      expect(result.blockReason).toBeDefined();
+      expect(result.suggestedDirectory).toBe('src/');
+      expect(result.suggestedPath).toBe('src/utils.ts');
+    });
+
+    it('should block JavaScript source files in root', async () => {
+      const result = await fileOrg.analyze('index.js');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('src/');
+    });
+
+    it('should block TypeScript test files in root', async () => {
+      const result = await fileOrg.analyze('utils.test.ts');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('tests/');
+      expect(result.suggestedPath).toBe('tests/utils.test.ts');
+    });
+
+    it('should block spec files in root', async () => {
+      const result = await fileOrg.analyze('api.spec.ts');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('tests/');
+    });
+
+    it('should block Python files in root', async () => {
+      const result = await fileOrg.analyze('main.py');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('src/');
+    });
+
+    it('should block Go files in root', async () => {
+      const result = await fileOrg.analyze('main.go');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('cmd/');
+    });
+
+    it('should block shell scripts in root', async () => {
+      const result = await fileOrg.analyze('deploy.sh');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('scripts/');
+    });
+
+    it('should block CSS files in root', async () => {
+      const result = await fileOrg.analyze('styles.css');
+
+      expect(result.blocked).toBe(true);
+      expect(result.suggestedDirectory).toBe('styles/');
+    });
+  });
+
+  describe('allowed root files', () => {
+    it('should allow JSON config files in root', async () => {
+      const result = await fileOrg.analyze('package.json');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow YAML config files in root', async () => {
+      const result = await fileOrg.analyze('config.yaml');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow Markdown files in root', async () => {
+      const result = await fileOrg.analyze('README.md');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow environment files in root', async () => {
+      const result = await fileOrg.analyze('.env');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow .env.local files in root', async () => {
+      const result = await fileOrg.analyze('.env.local');
+
+      expect(result.blocked).toBe(false);
+    });
+  });
+
+  describe('files in correct directories', () => {
+    it('should allow TypeScript files in src/', async () => {
+      const result = await fileOrg.analyze('src/utils.ts');
+
+      expect(result.blocked).toBe(false);
+      expect(result.issues?.some(i => i.type === 'wrong-directory')).toBeFalsy();
+    });
+
+    it('should allow test files in tests/', async () => {
+      const result = await fileOrg.analyze('tests/utils.test.ts');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow test files in __tests__/', async () => {
+      const result = await fileOrg.analyze('__tests__/utils.test.ts');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow scripts in scripts/', async () => {
+      const result = await fileOrg.analyze('scripts/deploy.sh');
+
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow Go files in cmd/', async () => {
+      const result = await fileOrg.analyze('cmd/main.go');
+
+      expect(result.blocked).toBe(false);
+    });
+  });
+
+  describe('files in wrong directories', () => {
+    it('should warn about test files in src/', async () => {
+      const result = await fileOrg.analyze('src/utils.test.ts');
+
+      expect(result.blocked).toBe(false);
+      expect(result.issues?.some(i => i.type === 'wrong-directory')).toBe(true);
+      expect(result.warnings?.length).toBeGreaterThan(0);
+    });
+
+    it('should warn about source files in tests/', async () => {
+      const result = await fileOrg.analyze('tests/utils.ts');
+
+      expect(result.blocked).toBe(false);
+      expect(result.issues?.some(i => i.type === 'wrong-directory')).toBe(true);
+    });
+  });
+
+  describe('formatter recommendations', () => {
+    it('should recommend Prettier for TypeScript', async () => {
+      const result = await fileOrg.analyze('src/utils.ts');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('Prettier');
+      expect(result.formatter!.command).toBe('prettier --write');
+    });
+
+    it('should recommend Black for Python', async () => {
+      const result = await fileOrg.analyze('src/main.py');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('Black');
+      expect(result.formatter!.command).toBe('black');
+    });
+
+    it('should recommend gofmt for Go', async () => {
+      const result = await fileOrg.analyze('cmd/main.go');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('gofmt');
+      expect(result.formatter!.command).toBe('gofmt -w');
+    });
+
+    it('should recommend rustfmt for Rust', async () => {
+      const result = await fileOrg.analyze('src/main.rs');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('rustfmt');
+    });
+
+    it('should recommend Prettier for CSS', async () => {
+      const result = await fileOrg.analyze('styles/app.css');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('Prettier');
+    });
+
+    it('should recommend Prettier for JSON', async () => {
+      const result = await fileOrg.analyze('config.json');
+
+      expect(result.formatter).toBeDefined();
+      expect(result.formatter!.name).toBe('Prettier');
+    });
+  });
+
+  describe('linter recommendations', () => {
+    it('should recommend ESLint for TypeScript', async () => {
+      const result = await fileOrg.analyze('src/utils.ts');
+
+      expect(result.linter).toBeDefined();
+      expect(result.linter!.name).toBe('ESLint');
+    });
+
+    it('should recommend Pylint for Python', async () => {
+      const result = await fileOrg.analyze('src/main.py');
+
+      expect(result.linter).toBeDefined();
+      expect(result.linter!.name).toBe('Pylint');
+    });
+
+    it('should recommend golangci-lint for Go', async () => {
+      const result = await fileOrg.analyze('cmd/main.go');
+
+      expect(result.linter).toBeDefined();
+      expect(result.linter!.name).toBe('golangci-lint');
+    });
+
+    it('should recommend Clippy for Rust', async () => {
+      const result = await fileOrg.analyze('src/main.rs');
+
+      expect(result.linter).toBeDefined();
+      expect(result.linter!.name).toBe('Clippy');
+    });
+  });
+
+  describe('organization issues', () => {
+    it('should detect root write issues', async () => {
+      const result = await fileOrg.analyze('utils.ts');
+
+      expect(result.issues).toBeDefined();
+      expect(result.issues!.some(i => i.type === 'root-write')).toBe(true);
+      expect(result.issues![0].severity).toBe('error');
+    });
+
+    it('should provide suggested fixes', async () => {
+      const result = await fileOrg.analyze('utils.ts');
+
+      expect(result.issues).toBeDefined();
+      expect(result.issues![0].suggestedFix).toBeDefined();
+    });
+  });
+
+  describe('helper methods', () => {
+    it('should get suggested directory for file', () => {
+      expect(fileOrg.getSuggestedDirectory('app.ts')).toBe('src/');
+      expect(fileOrg.getSuggestedDirectory('test.spec.ts')).toBe('tests/');
+      expect(fileOrg.getSuggestedDirectory('deploy.sh')).toBe('scripts/');
+    });
+
+    it('should check if file would be blocked', () => {
+      expect(fileOrg.wouldBlock('utils.ts')).toBe(true);
+      expect(fileOrg.wouldBlock('package.json')).toBe(false);
+      expect(fileOrg.wouldBlock('src/utils.ts')).toBe(false);
+    });
+
+    it('should allow setting project root', () => {
+      fileOrg.setProjectRoot('/custom/project');
+      // No error should be thrown
+    });
+
+    it('should get all formatters', () => {
+      const formatters = fileOrg.getAllFormatters();
+
+      expect(formatters['.ts']).toBeDefined();
+      expect(formatters['.py']).toBeDefined();
+      expect(formatters['.go']).toBeDefined();
+    });
+
+    it('should get all linters', () => {
+      const linters = fileOrg.getAllLinters();
+
+      expect(linters['.ts']).toBeDefined();
+      expect(linters['.py']).toBeDefined();
+      expect(linters['.go']).toBeDefined();
+    });
+  });
+
+  describe('file type detection', () => {
+    it('should detect TypeScript source type', async () => {
+      const result = await fileOrg.analyze('src/app.ts');
+
+      expect(result.fileType).toBe('TypeScript source');
+    });
+
+    it('should detect test file type', async () => {
+      const result = await fileOrg.analyze('tests/app.test.ts');
+
+      expect(result.fileType).toBe('test file');
+    });
+
+    it('should detect spec file type', async () => {
+      const result = await fileOrg.analyze('spec/app.spec.ts');
+
+      expect(result.fileType).toBe('spec file');
+    });
+
+    it('should detect shell script type', async () => {
+      const result = await fileOrg.analyze('scripts/build.sh');
+
+      expect(result.fileType).toBe('shell script');
+    });
+
+    it('should detect SQL file type', async () => {
+      const result = await fileOrg.analyze('migrations/001_init.sql');
+
+      expect(result.fileType).toBe('SQL file');
+    });
+
+    it('should detect image file type', async () => {
+      const result = await fileOrg.analyze('assets/logo.png');
+
+      expect(result.fileType).toBe('image');
+    });
+  });
+});

package/__tests__/hooks/git-commit.test.ts

@@ -0,0 +1,336 @@
+/**
+ * V3 Git Commit Hook Tests
+ *
+ * Tests for git commit message formatting and validation.
+ *
+ * @module v3/shared/hooks/__tests__/git-commit.test
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  createHookRegistry,
+  createGitCommitHook,
+  GitCommitHook,
+  HookRegistry,
+} from '../../src/hooks/index.js';
+
+describe('GitCommitHook', () => {
+  let registry: HookRegistry;
+  let gitCommit: GitCommitHook;
+
+  beforeEach(() => {
+    registry = createHookRegistry();
+    gitCommit = createGitCommitHook(registry);
+  });
+
+  describe('commit type detection', () => {
+    it('should detect feat type from message', async () => {
+      const result = await gitCommit.process('Add user authentication');
+
+      expect(result.commitType).toBe('feat');
+      expect(result.modifiedMessage).toMatch(/^feat:/);
+    });
+
+    it('should detect fix type from message', async () => {
+      const result = await gitCommit.process('Fix login validation bug');
+
+      expect(result.commitType).toBe('fix');
+      expect(result.modifiedMessage).toMatch(/^fix:/);
+    });
+
+    it('should detect docs type from message', async () => {
+      const result = await gitCommit.process('Update README documentation');
+
+      expect(result.commitType).toBe('docs');
+      expect(result.modifiedMessage).toMatch(/^docs:/);
+    });
+
+    it('should detect refactor type from message', async () => {
+      const result = await gitCommit.process('Refactor authentication module');
+
+      expect(result.commitType).toBe('refactor');
+      expect(result.modifiedMessage).toMatch(/^refactor:/);
+    });
+
+    it('should detect test type from message', async () => {
+      const result = await gitCommit.process('Add unit tests for user service');
+
+      expect(result.commitType).toBe('test');
+      expect(result.modifiedMessage).toMatch(/^test:/);
+    });
+
+    it('should detect perf type from message', async () => {
+      const result = await gitCommit.process('Optimize database queries');
+
+      expect(result.commitType).toBe('perf');
+      expect(result.modifiedMessage).toMatch(/^perf:/);
+    });
+
+    it('should detect build type from message', async () => {
+      const result = await gitCommit.process('Update webpack configuration');
+
+      expect(result.commitType).toBe('build');
+      expect(result.modifiedMessage).toMatch(/^build:/);
+    });
+
+    it('should detect ci type from message', async () => {
+      const result = await gitCommit.process('Update GitHub Actions workflow');
+
+      expect(result.commitType).toBe('ci');
+      expect(result.modifiedMessage).toMatch(/^ci:/);
+    });
+
+    it('should detect chore type from message', async () => {
+      const result = await gitCommit.process('Update dependencies');
+
+      expect(result.commitType).toBe('chore');
+      expect(result.modifiedMessage).toMatch(/^chore:/);
+    });
+
+    it('should detect revert type from message', async () => {
+      const result = await gitCommit.process('Revert previous commit');
+
+      expect(result.commitType).toBe('revert');
+      expect(result.modifiedMessage).toMatch(/^revert:/);
+    });
+  });
+
+  describe('preserving existing prefixes', () => {
+    it('should not add duplicate prefix if already present', async () => {
+      const result = await gitCommit.process('feat: add user authentication');
+
+      expect(result.commitType).toBe('feat');
+      // Should not have double prefix
+      expect(result.modifiedMessage).not.toMatch(/^feat:.*feat:/);
+    });
+
+    it('should detect type from existing prefix', async () => {
+      const result = await gitCommit.process('fix(auth): resolve login issue');
+
+      expect(result.commitType).toBe('fix');
+    });
+
+    it('should handle scoped commits', async () => {
+      const result = await gitCommit.process('feat(api): add new endpoint');
+
+      expect(result.commitType).toBe('feat');
+    });
+  });
+
+  describe('ticket extraction', () => {
+    it('should extract JIRA ticket from branch name', async () => {
+      const result = await gitCommit.process('Add feature', 'feature/ABC-123-new-feature');
+
+      expect(result.ticketReference).toBe('ABC-123');
+      expect(result.modifiedMessage).toContain('Refs: ABC-123');
+    });
+
+    it('should extract GitHub issue from branch name', async () => {
+      const result = await gitCommit.process('Fix bug', 'fix/#456-login-bug');
+
+      expect(result.ticketReference).toBe('#456');
+      expect(result.modifiedMessage).toContain('Refs: #456');
+    });
+
+    it('should not duplicate ticket if already in message', async () => {
+      const result = await gitCommit.process('Fix ABC-123 bug', 'feature/ABC-123-test');
+
+      // Should only appear once
+      const matches = result.modifiedMessage.match(/ABC-123/g);
+      expect(matches).toBeDefined();
+      expect(matches!.length).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe('co-author addition', () => {
+    it('should add co-author by default', async () => {
+      const result = await gitCommit.process('Add feature');
+
+      expect(result.coAuthorAdded).toBe(true);
+      expect(result.modifiedMessage).toContain('Co-Authored-By:');
+      expect(result.modifiedMessage).toContain('Claude');
+    });
+
+    it('should add Claude Code reference', async () => {
+      const result = await gitCommit.process('Add feature');
+
+      expect(result.modifiedMessage).toContain('Claude Code');
+    });
+
+    it('should not duplicate co-author if already present', async () => {
+      const result = await gitCommit.process('Add feature\n\nCo-Authored-By: Someone <some@email.com>');
+
+      // Should still add Claude co-author
+      expect(result.modifiedMessage).toContain('Claude');
+    });
+  });
+
+  describe('validation', () => {
+    it('should warn about missing conventional prefix', async () => {
+      const hook = createGitCommitHook(registry, { requireConventional: true });
+      const result = await hook.process('Some random message');
+
+      // Message should be modified to include prefix
+      expect(result.suggestions).toBeDefined();
+    });
+
+    it('should warn about long subject line', async () => {
+      const longMessage = 'This is a very long commit message that exceeds the recommended length for commit subject lines which should be concise';
+      const result = await gitCommit.process(longMessage);
+
+      expect(result.validationIssues).toBeDefined();
+      expect(result.validationIssues!.some(i => i.type === 'length')).toBe(true);
+    });
+
+    it('should warn about trailing period in subject', async () => {
+      const result = await gitCommit.process('Add new feature.');
+
+      expect(result.validationIssues).toBeDefined();
+      expect(result.validationIssues!.some(i => i.description.includes('period'))).toBe(true);
+    });
+
+    it('should detect breaking change indicator', async () => {
+      const result = await gitCommit.process('feat!: major API change');
+
+      expect(result.validationIssues).toBeDefined();
+      expect(result.validationIssues!.some(i => i.type === 'breaking')).toBe(true);
+    });
+
+    it('should detect BREAKING CHANGE footer', async () => {
+      const result = await gitCommit.process('feat: add feature\n\nBREAKING CHANGE: API changed');
+
+      expect(result.validationIssues).toBeDefined();
+      expect(result.validationIssues!.some(i => i.type === 'breaking')).toBe(true);
+    });
+  });
+
+  describe('configuration', () => {
+    it('should respect maxSubjectLength config', async () => {
+      const hook = createGitCommitHook(registry, { maxSubjectLength: 50 });
+      const result = await hook.process('This is a message that is definitely longer than fifty characters');
+
+      expect(result.validationIssues).toBeDefined();
+      expect(result.validationIssues!.some(i => i.type === 'length')).toBe(true);
+    });
+
+    it('should allow disabling co-author', async () => {
+      const hook = createGitCommitHook(registry, { addCoAuthor: false });
+      const result = await hook.process('Add feature');
+
+      expect(result.coAuthorAdded).toBe(false);
+      expect(result.modifiedMessage).not.toContain('Co-Authored-By');
+    });
+
+    it('should allow disabling Claude reference', async () => {
+      const hook = createGitCommitHook(registry, { addClaudeReference: false });
+      const result = await hook.process('Add feature');
+
+      expect(result.modifiedMessage).not.toContain('Claude Code');
+    });
+
+    it('should allow custom co-author', async () => {
+      const hook = createGitCommitHook(registry, {
+        coAuthor: { name: 'Custom AI', email: 'ai@example.com' },
+      });
+      const result = await hook.process('Add feature');
+
+      expect(result.modifiedMessage).toContain('Custom AI');
+      expect(result.modifiedMessage).toContain('ai@example.com');
+    });
+  });
+
+  describe('helper methods', () => {
+    it('should format message for git heredoc', () => {
+      const formatted = gitCommit.formatForGit('Test message');
+
+      expect(formatted).toContain('$(cat <<');
+      expect(formatted).toContain('Test message');
+      expect(formatted).toContain('EOF');
+    });
+
+    it('should generate full commit command', () => {
+      const command = gitCommit.generateCommitCommand('Test message');
+
+      expect(command).toContain('git commit -m');
+      expect(command).toContain('Test message');
+    });
+
+    it('should get commit type description', () => {
+      expect(gitCommit.getCommitTypeDescription('feat')).toContain('feature');
+      expect(gitCommit.getCommitTypeDescription('fix')).toContain('bug fix');
+      expect(gitCommit.getCommitTypeDescription('docs')).toContain('Documentation');
+    });
+
+    it('should get all commit types', () => {
+      const types = gitCommit.getAllCommitTypes();
+
+      expect(types.length).toBeGreaterThan(0);
+      expect(types.some(t => t.type === 'feat')).toBe(true);
+      expect(types.some(t => t.type === 'fix')).toBe(true);
+    });
+
+    it('should get current config', () => {
+      const config = gitCommit.getConfig();
+
+      expect(config.maxSubjectLength).toBeDefined();
+      expect(config.addCoAuthor).toBe(true);
+    });
+
+    it('should update config', () => {
+      gitCommit.setConfig({ addCoAuthor: false });
+      const config = gitCommit.getConfig();
+
+      expect(config.addCoAuthor).toBe(false);
+    });
+  });
+
+  describe('message case handling', () => {
+    it('should lowercase first letter after prefix', async () => {
+      const result = await gitCommit.process('Add new feature');
+
+      expect(result.modifiedMessage).toMatch(/^feat: add/);
+    });
+
+    it('should preserve acronyms', async () => {
+      const result = await gitCommit.process('Add API endpoint');
+
+      // Should not lowercase API
+      expect(result.modifiedMessage).toMatch(/API/);
+    });
+  });
+
+  describe('full message processing', () => {
+    it('should process complete message with all modifications', async () => {
+      const result = await gitCommit.process(
+        'Implement user authentication',
+        'feature/AUTH-123-login'
+      );
+
+      // Should have commit type prefix
+      expect(result.modifiedMessage).toMatch(/^feat:/);
+
+      // Should have ticket reference
+      expect(result.modifiedMessage).toContain('AUTH-123');
+
+      // Should have Claude reference
+      expect(result.modifiedMessage).toContain('Claude Code');
+
+      // Should have co-author
+      expect(result.modifiedMessage).toContain('Co-Authored-By');
+    });
+
+    it('should return original message unchanged in result', async () => {
+      const original = 'Original message';
+      const result = await gitCommit.process(original);
+
+      expect(result.originalMessage).toBe(original);
+    });
+
+    it('should track suggestions for modifications', async () => {
+      const result = await gitCommit.process('Add feature', 'feature/JIRA-123');
+
+      expect(result.suggestions).toBeDefined();
+      expect(result.suggestions!.length).toBeGreaterThan(0);
+    });
+  });
+});

package/__tests__/hooks/index.ts

@@ -0,0 +1,23 @@
+/**
+ * V3 Hooks Tests Index
+ *
+ * Exports all hook tests for the V3 hooks system.
+ *
+ * @module v3/shared/hooks/__tests__
+ */
+
+// Test files are automatically discovered by vitest
+// This file serves as documentation of available tests
+
+export const testFiles = [
+  './task-hooks.test.ts',
+  './session-hooks.test.ts',
+  './bash-safety.test.ts',
+  './file-organization.test.ts',
+  './git-commit.test.ts',
+];
+
+export const testCategories = {
+  'Core Hooks': ['task-hooks.test.ts', 'session-hooks.test.ts'],
+  'Safety Hooks': ['bash-safety.test.ts', 'file-organization.test.ts', 'git-commit.test.ts'],
+};