oh-my-claude-sisyphus 3.7.16 → 3.8.1

package/dist/__tests__/hooks.test.js

@@ -108,53 +108,33 @@ describe('Keyword Detector', () => {
             expect(detected[0].keyword).toBe('ultrathink');
         });
         it('should detect think keyword', () => {
-            const detected = detectKeywordsWithType('Let me think about it');
+            const detected = detectKeywordsWithType('Let me think hard about it');
             expect(detected).toHaveLength(1);
             expect(detected[0].type).toBe('ultrathink');
-            expect(detected[0].keyword).toBe('think');
+            expect(detected[0].keyword).toBe('think hard');
         });
-        it('should detect search keywords', () => {
-            const searchTerms = ['search', 'find', 'locate', 'lookup', 'explore'];
-            for (const term of searchTerms) {
-                const detected = detectKeywordsWithType(`Please ${term} this file`);
-                expect(detected).toHaveLength(1);
-                expect(detected[0].type).toBe('search');
-                expect(detected[0].keyword).toBe(term);
-            }
-        });
-        it('should detect search patterns', () => {
+        it('should detect deepsearch keywords for codebase search', () => {
             const patterns = [
-                'where is the config',
-                'show me all files',
-                'list all functions'
+                'search the codebase',
+                'find in codebase',
+                'search code for pattern'
             ];
             for (const pattern of patterns) {
                 const detected = detectKeywordsWithType(pattern);
                 expect(detected.length).toBeGreaterThan(0);
-                const hasSearchType = detected.some(d => d.type === 'search');
-                expect(hasSearchType).toBe(true);
-            }
-        });
-        it('should detect analyze keywords', () => {
-            const analyzeTerms = ['analyze', 'investigate', 'examine', 'debug'];
-            for (const term of analyzeTerms) {
-                const detected = detectKeywordsWithType(`Please ${term} this code`);
-                expect(detected).toHaveLength(1);
-                expect(detected[0].type).toBe('analyze');
-                expect(detected[0].keyword).toBe(term);
+                expect(detected[0].type).toBe('deepsearch');
             }
         });
-        it('should detect analyze patterns', () => {
+        it('should detect analyze keywords with restricted patterns', () => {
             const patterns = [
-                'why is this failing',
-                'how does this work',
-                'how to implement this'
+                'deep analyze this code',
+                'investigate the bug',
+                'debug the issue'
             ];
             for (const pattern of patterns) {
                 const detected = detectKeywordsWithType(pattern);
                 expect(detected.length).toBeGreaterThan(0);
-                const hasAnalyzeType = detected.some(d => d.type === 'analyze');
-                expect(hasAnalyzeType).toBe(true);
+                expect(detected[0].type).toBe('analyze');
             }
         });
         it('should be case insensitive', () => {
@@ -173,27 +153,215 @@ describe('Keyword Detector', () => {
             expect(detected[0].keyword).toBe('ultrawork');
         });
         it('should include position information', () => {
-            const detected = detectKeywordsWithType('Start search here');
-            expect(detected[0].position).toBe(6); // Position of 'search'
+            const detected = detectKeywordsWithType('Start search the codebase here');
+            expect(detected[0].position).toBeGreaterThanOrEqual(0);
         });
         it('should return empty array for no matches', () => {
             const detected = detectKeywordsWithType('Just plain text');
             expect(detected).toEqual([]);
         });
         it('should detect multiple different keyword types', () => {
-            const text = 'search and analyze this code';
+            const text = 'search the codebase and investigate the bug';
             const detected = detectKeywordsWithType(text);
             expect(detected.length).toBeGreaterThanOrEqual(2);
             const types = detected.map(d => d.type);
-            expect(types).toContain('search');
+            expect(types).toContain('deepsearch');
             expect(types).toContain('analyze');
         });
+        // New keyword types tests
+        it('should detect cancel keyword', () => {
+            const detected = detectKeywordsWithType('stop this task');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('cancel');
+            expect(detected[0].keyword).toBe('stop');
+        });
+        it('should detect cancel keyword variations', () => {
+            const cancelTerms = ['stop', 'cancel', 'abort'];
+            for (const term of cancelTerms) {
+                const detected = detectKeywordsWithType(`Please ${term} the process`);
+                expect(detected).toHaveLength(1);
+                expect(detected[0].type).toBe('cancel');
+                expect(detected[0].keyword).toBe(term);
+            }
+        });
+        it('should detect ultrapilot keyword', () => {
+            const detected = detectKeywordsWithType('use ultrapilot for this');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('ultrapilot');
+            expect(detected[0].keyword).toBe('ultrapilot');
+        });
+        it('should detect ultrapilot patterns', () => {
+            const patterns = [
+                'ultrapilot this project',
+                'parallel build the app',
+                'swarm build the system'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasUltrapilot = detected.some(d => d.type === 'ultrapilot');
+                expect(hasUltrapilot).toBe(true);
+            }
+        });
+        it('should detect ecomode keyword', () => {
+            const detected = detectKeywordsWithType('use ecomode for this');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('ecomode');
+            expect(detected[0].keyword).toBe('ecomode');
+        });
+        it('should detect ecomode variations', () => {
+            const ecoTerms = ['eco', 'ecomode', 'efficient', 'save-tokens', 'budget'];
+            for (const term of ecoTerms) {
+                const detected = detectKeywordsWithType(`Use ${term} mode`);
+                expect(detected).toHaveLength(1);
+                expect(detected[0].type).toBe('ecomode');
+                expect(detected[0].keyword).toBe(term);
+            }
+        });
+        it('should detect swarm keyword', () => {
+            const detected = detectKeywordsWithType('swarm 5 agents to fix this');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('swarm');
+            expect(detected[0].keyword).toBe('swarm 5 agents');
+        });
+        it('should detect coordinated agents pattern', () => {
+            const detected = detectKeywordsWithType('use coordinated agents');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('swarm');
+            expect(detected[0].keyword).toBe('coordinated agents');
+        });
+        it('should detect pipeline keyword', () => {
+            const detected = detectKeywordsWithType('pipeline this task');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('pipeline');
+            expect(detected[0].keyword).toBe('pipeline');
+        });
+        it('should detect chain agents pattern', () => {
+            const detected = detectKeywordsWithType('chain agents together');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('pipeline');
+            expect(detected[0].keyword).toBe('chain agents');
+        });
+        it('should detect ralplan keyword', () => {
+            const detected = detectKeywordsWithType('ralplan this feature');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('ralplan');
+            expect(detected[0].keyword).toBe('ralplan');
+        });
+        it('should detect plan patterns', () => {
+            const patterns = [
+                'plan this feature',
+                'plan the refactoring'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasPlan = detected.some(d => d.type === 'plan');
+                expect(hasPlan).toBe(true);
+            }
+        });
+        it('should detect tdd keyword', () => {
+            const detected = detectKeywordsWithType('use tdd for this');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('tdd');
+            expect(detected[0].keyword).toBe('tdd');
+        });
+        it('should detect tdd patterns', () => {
+            const patterns = [
+                'test first development',
+                'red green refactor'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasTDD = detected.some(d => d.type === 'tdd');
+                expect(hasTDD).toBe(true);
+            }
+        });
+        it('should detect research keyword', () => {
+            const detected = detectKeywordsWithType('research this topic');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('research');
+            expect(detected[0].keyword).toBe('research');
+        });
+        it('should detect research patterns', () => {
+            const patterns = [
+                'analyze data from the file',
+                'run statistics on this'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasResearch = detected.some(d => d.type === 'research');
+                expect(hasResearch).toBe(true);
+            }
+        });
+        it('should detect deepsearch keyword', () => {
+            const detected = detectKeywordsWithType('deepsearch for the pattern');
+            expect(detected).toHaveLength(1);
+            expect(detected[0].type).toBe('deepsearch');
+            expect(detected[0].keyword).toBe('deepsearch');
+        });
+        it('should detect deepsearch patterns', () => {
+            const patterns = [
+                'search the codebase for errors',
+                'search codebase for pattern',
+                'find in codebase',
+                'find in all files'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasDeepsearch = detected.some(d => d.type === 'deepsearch');
+                expect(hasDeepsearch).toBe(true);
+            }
+        });
+        it('should NOT detect deepsearch for generic find', () => {
+            const patterns = [
+                'find the file',
+                'find this function',
+                'search for help'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                const hasDeepsearch = detected.some(d => d.type === 'deepsearch');
+                expect(hasDeepsearch).toBe(false);
+            }
+        });
+        it('should detect analyze patterns with restrictions', () => {
+            const patterns = [
+                'deep analyze this code',
+                'investigate the bug',
+                'investigate this issue',
+                'debug the problem',
+                'debug this error'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                expect(detected.length).toBeGreaterThan(0);
+                const hasAnalyze = detected.some(d => d.type === 'analyze');
+                expect(hasAnalyze).toBe(true);
+            }
+        });
+        it('should NOT detect analyze for generic patterns', () => {
+            const patterns = [
+                'how to do this',
+                'understand this code',
+                'review this code',
+                'analyze without context'
+            ];
+            for (const pattern of patterns) {
+                const detected = detectKeywordsWithType(pattern);
+                const hasAnalyze = detected.some(d => d.type === 'analyze');
+                expect(hasAnalyze).toBe(false);
+            }
+        });
     });
     describe('hasKeyword', () => {
         it('should return true when keyword exists', () => {
             expect(hasKeyword('use ultrawork mode')).toBe(true);
-            expect(hasKeyword('search for files')).toBe(true);
-            expect(hasKeyword('analyze this')).toBe(true);
+            expect(hasKeyword('search the codebase')).toBe(true);
+            expect(hasKeyword('investigate the bug')).toBe(true);
         });
         it('should return false when no keyword exists', () => {
             expect(hasKeyword('just normal text')).toBe(false);
@@ -204,7 +372,7 @@ describe('Keyword Detector', () => {
             expect(hasKeyword(text)).toBe(false);
         });
         it('should detect keywords outside code blocks', () => {
-            const text = 'Please search\n```\nsome code\n```\nfor this';
+            const text = 'Please search the codebase\n```\nsome code\n```\nfor this';
             expect(hasKeyword(text)).toBe(true);
         });
         it('should handle empty string', () => {
@@ -219,20 +387,20 @@ describe('Keyword Detector', () => {
             expect(primary).not.toBeNull();
             expect(primary.type).toBe('ultrawork');
         });
-        it('should return ultrathink when no ultrawork', () => {
-            const text = 'search and think about this';
+        it('should return ultrathink when present', () => {
+            const text = 'think hard about this problem';
             const primary = getPrimaryKeyword(text);
             expect(primary).not.toBeNull();
             expect(primary.type).toBe('ultrathink');
         });
-        it('should return search when only search keyword', () => {
-            const text = 'find all files';
+        it('should return deepsearch for codebase search', () => {
+            const text = 'find in codebase';
             const primary = getPrimaryKeyword(text);
             expect(primary).not.toBeNull();
-            expect(primary.type).toBe('search');
+            expect(primary.type).toBe('deepsearch');
         });
         it('should return analyze when only analyze keyword', () => {
-            const text = 'investigate this issue';
+            const text = 'investigate the issue';
             const primary = getPrimaryKeyword(text);
             expect(primary).not.toBeNull();
             expect(primary.type).toBe('analyze');
@@ -242,18 +410,89 @@ describe('Keyword Detector', () => {
             expect(primary).toBeNull();
         });
         it('should ignore code blocks', () => {
-            const text = '```\nultrawork code\n```\nsearch this';
+            const text = '```\nultrawork code\n```\nsearch the codebase';
             const primary = getPrimaryKeyword(text);
             expect(primary).not.toBeNull();
-            expect(primary.type).toBe('search');
+            expect(primary.type).toBe('deepsearch');
         });
         it('should return first detected when same priority', () => {
-            // Both search and analyze have same priority
-            const text = 'search and analyze';
+            // deepsearch has higher priority than analyze in the priority list
+            const text = 'search the codebase and investigate the bug';
             const primary = getPrimaryKeyword(text);
             expect(primary).not.toBeNull();
-            // Should return search as it comes first in priority list
-            expect(primary.type).toBe('search');
+            // Should return deepsearch as it comes first in priority list
+            expect(primary.type).toBe('deepsearch');
+        });
+        // New priority tests for new keywords
+        it('should give cancel highest priority', () => {
+            const primary = getPrimaryKeyword('stop searching for files');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('cancel');
+        });
+        it('should give cancel priority over analyze', () => {
+            const primary = getPrimaryKeyword('cancel this investigation');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('cancel');
+        });
+        it('should prioritize cancel over all other keywords', () => {
+            const primary = getPrimaryKeyword('stop ultrawork and search');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('cancel');
+        });
+        it('should prioritize ralph after cancel', () => {
+            const primary = getPrimaryKeyword('ralph mode for the task');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('ralph');
+        });
+        it('should prioritize ultrapilot correctly', () => {
+            const primary = getPrimaryKeyword('ultrapilot this task');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('ultrapilot');
+        });
+        it('should prioritize ecomode correctly', () => {
+            const primary = getPrimaryKeyword('use efficient mode for this');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('ecomode');
+        });
+        it('should prioritize swarm correctly', () => {
+            const primary = getPrimaryKeyword('swarm 5 agents for this');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('swarm');
+        });
+        it('should prioritize pipeline correctly', () => {
+            const primary = getPrimaryKeyword('pipeline the task');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('pipeline');
+        });
+        it('should prioritize ralplan over plan', () => {
+            const primary = getPrimaryKeyword('ralplan this project');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('ralplan');
+        });
+        it('should detect plan correctly', () => {
+            const primary = getPrimaryKeyword('plan this feature');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('plan');
+        });
+        it('should prioritize tdd correctly', () => {
+            const primary = getPrimaryKeyword('tdd for this feature');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('tdd');
+        });
+        it('should prioritize research correctly', () => {
+            const primary = getPrimaryKeyword('research this topic');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('research');
+        });
+        it('should prioritize deepsearch over generic search', () => {
+            const primary = getPrimaryKeyword('search the codebase');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('deepsearch');
+        });
+        it('should prioritize analyze with restricted pattern', () => {
+            const primary = getPrimaryKeyword('investigate the bug');
+            expect(primary).not.toBeNull();
+            expect(primary.type).toBe('analyze');
         });
     });
 });
@@ -577,7 +816,7 @@ describe('Hook Output Structure', () => {
 describe('Integration: Keyword Detection with Code Blocks', () => {
     it('should detect keywords outside code and ignore inside', () => {
         const text = `
-Please search for files
+Please search the codebase
 
 \`\`\`javascript
 // This search should be ignored
@@ -586,25 +825,25 @@ function search() {
 }
 \`\`\`
 
-Now analyze the results
+Now investigate the bug
     `;
         const detected = detectKeywordsWithType(removeCodeBlocks(text));
         const types = detected.map(d => d.type);
-        expect(types).toContain('search');
+        expect(types).toContain('deepsearch');
         expect(types).toContain('analyze');
         // Should only detect the ones outside code blocks
-        expect(detected.filter(d => d.type === 'search')).toHaveLength(1);
+        expect(detected.filter(d => d.type === 'deepsearch')).toHaveLength(1);
         expect(detected.filter(d => d.type === 'analyze')).toHaveLength(1);
     });
     it('should handle inline code with keywords', () => {
-        const text = 'Use the `search` command to find files';
+        const text = 'Use the `deepsearch` command to find in codebase';
         const cleanText = removeCodeBlocks(text);
         const detected = detectKeywordsWithType(cleanText);
-        // The word 'find' should still be detected
-        expect(detected.some(d => d.type === 'search')).toBe(true);
+        // The phrase 'find in codebase' should still be detected
+        expect(detected.some(d => d.type === 'deepsearch')).toBe(true);
     });
     it('should prioritize ultrawork even with other keywords', () => {
-        const text = 'search, analyze, and use ultrawork mode';
+        const text = 'search the codebase, investigate the bug, and use ultrawork mode';
         const primary = getPrimaryKeyword(text);
         expect(primary).not.toBeNull();
         expect(primary.type).toBe('ultrawork');
@@ -631,33 +870,33 @@ describe('Edge Cases', () => {
     });
     describe('Whitespace handling', () => {
         it('should detect keywords with extra whitespace', () => {
-            const text = '   search    for   files   ';
+            const text = '   search    the   codebase   ';
             expect(hasKeyword(text)).toBe(true);
         });
         it('should handle newlines and tabs', () => {
-            const text = 'search\n\tfor\r\nfiles';
+            const text = 'search\n\tthe\r\ncodebase';
             const detected = detectKeywordsWithType(text);
-            expect(detected.some(d => d.type === 'search')).toBe(true);
+            expect(detected.some(d => d.type === 'deepsearch')).toBe(true);
         });
     });
     describe('Unicode and special characters', () => {
         it('should handle unicode characters', () => {
-            const text = 'search for files with émojis 🔍';
+            const text = 'search the codebase with émojis 🔍';
             expect(hasKeyword(text)).toBe(true);
         });
         it('should handle mixed scripts', () => {
-            const text = 'Please search 搜索 искать';
+            const text = 'Please search the codebase 搜索 искать';
             const detected = detectKeywordsWithType(text);
-            expect(detected.some(d => d.keyword === 'search')).toBe(true);
+            expect(detected.some(d => d.type === 'deepsearch')).toBe(true);
         });
     });
     describe('Very long inputs', () => {
         it('should handle long text efficiently', () => {
-            const longText = 'plain text '.repeat(1000) + ' search here';
+            const longText = 'plain text '.repeat(1000) + ' search the codebase';
             expect(hasKeyword(longText)).toBe(true);
         });
         it('should handle many code blocks', () => {
-            const manyBlocks = '```code```\n'.repeat(100) + 'search here';
+            const manyBlocks = '```code```\n'.repeat(100) + 'search the codebase';
             const cleaned = removeCodeBlocks(manyBlocks);
             expect(hasKeyword(cleaned)).toBe(true);
         });