@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/npm/tests/unit/completion-prompt.test.js

@@ -0,0 +1,379 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { ProbeAgent } from '../../src/agent/ProbeAgent.js';
+
+describe('ProbeAgent completionPrompt option', () => {
+  describe('constructor configuration', () => {
+    test('should store completionPrompt option in constructor', () => {
+      const agent = new ProbeAgent({
+        completionPrompt: 'Please double-check your answer',
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBe('Please double-check your answer');
+    });
+
+    test('should default to null when no completionPrompt option provided', () => {
+      const agent = new ProbeAgent({
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBeNull();
+    });
+
+    test('should handle empty string completionPrompt as null', () => {
+      const agent = new ProbeAgent({
+        completionPrompt: '',
+        path: process.cwd()
+      });
+
+      // Empty string is falsy, so it becomes null due to || operator
+      expect(agent.completionPrompt).toBeNull();
+    });
+
+    test('should preserve multi-line completionPrompt', () => {
+      const multiLinePrompt = `Please review the response:
+1. Check for accuracy
+2. Verify completeness
+3. Ensure proper formatting`;
+
+      const agent = new ProbeAgent({
+        completionPrompt: multiLinePrompt,
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBe(multiLinePrompt);
+    });
+  });
+
+  describe('clone behavior', () => {
+    test('should preserve completionPrompt in clone', () => {
+      const baseAgent = new ProbeAgent({
+        completionPrompt: 'Verify your response',
+        path: process.cwd()
+      });
+
+      const cloned = baseAgent.clone();
+
+      expect(cloned.completionPrompt).toBe(baseAgent.completionPrompt);
+      expect(cloned.completionPrompt).toBe('Verify your response');
+    });
+
+    test('should preserve absence of completionPrompt in clone', () => {
+      const baseAgent = new ProbeAgent({
+        path: process.cwd()
+        // No completionPrompt specified
+      });
+
+      const cloned = baseAgent.clone();
+
+      expect(cloned.completionPrompt).toBeNull();
+      expect(baseAgent.completionPrompt).toBeNull();
+    });
+
+    test('should allow override of completionPrompt in clone', () => {
+      const baseAgent = new ProbeAgent({
+        completionPrompt: 'Original prompt',
+        path: process.cwd()
+      });
+
+      const cloned = baseAgent.clone({
+        overrides: {
+          completionPrompt: 'Overridden prompt'
+        }
+      });
+
+      expect(cloned.completionPrompt).toBe('Overridden prompt');
+      expect(baseAgent.completionPrompt).toBe('Original prompt');
+    });
+  });
+
+  describe('integration with other options', () => {
+    test('should work alongside other agent options', () => {
+      const agent = new ProbeAgent({
+        completionPrompt: 'Review the answer',
+        systemPrompt: 'You are a helpful assistant',
+        allowEdit: true,
+        enableBash: false,
+        debug: false,
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBe('Review the answer');
+      expect(agent.customPrompt).toBe('You are a helpful assistant');
+      expect(agent.allowEdit).toBe(true);
+      expect(agent.enableBash).toBe(false);
+    });
+
+    test('should work with schema option', () => {
+      const agent = new ProbeAgent({
+        completionPrompt: 'Verify JSON structure',
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBe('Verify JSON structure');
+    });
+
+    test('should work with disableMermaidValidation', () => {
+      const agent = new ProbeAgent({
+        completionPrompt: 'Check diagrams',
+        disableMermaidValidation: true,
+        path: process.cwd()
+      });
+
+      expect(agent.completionPrompt).toBe('Check diagrams');
+      expect(agent.disableMermaidValidation).toBe(true);
+    });
+  });
+
+  describe('_completionPromptProcessed flag behavior', () => {
+    test('should not trigger completionPrompt when _completionPromptProcessed is true', async () => {
+      // This test verifies that the infinite loop prevention works
+      // by checking that _completionPromptProcessed flag is properly handled
+      const agent = new ProbeAgent({
+        completionPrompt: 'Review this',
+        path: process.cwd()
+      });
+
+      // The _completionPromptProcessed flag should prevent recursive calls
+      // This is tested indirectly through the logic in ProbeAgent.answer()
+      expect(agent.completionPrompt).toBe('Review this');
+    });
+  });
+});
+
+describe('completionPrompt message format', () => {
+  test('should format completion prompt message correctly', () => {
+    const completionPrompt = 'Please verify the accuracy of your response.';
+    const finalResult = 'This is the AI response.';
+
+    // Simulate the message format used in ProbeAgent
+    const formattedMessage = `${completionPrompt}
+
+Here is the result to review:
+<result>
+${finalResult}
+</result>
+
+After reviewing, provide your final answer using attempt_completion.`;
+
+    expect(formattedMessage).toContain(completionPrompt);
+    expect(formattedMessage).toContain(finalResult);
+    expect(formattedMessage).toContain('<result>');
+    expect(formattedMessage).toContain('</result>');
+    expect(formattedMessage).toContain('attempt_completion');
+  });
+});
+
+describe('completionPrompt with delegate tool', () => {
+  test('should preserve completionPrompt when enableDelegate is true', () => {
+    const agent = new ProbeAgent({
+      completionPrompt: 'Review the delegated response',
+      enableDelegate: true,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe('Review the delegated response');
+    expect(agent.enableDelegate).toBe(true);
+  });
+
+  test('should not inherit completionPrompt in delegate subagent by design', () => {
+    // The delegate tool creates its own ProbeAgent without completionPrompt
+    // This is by design - subagents should not have completion validation
+    const parentAgent = new ProbeAgent({
+      completionPrompt: 'Parent validation prompt',
+      enableDelegate: true,
+      path: process.cwd()
+    });
+
+    // When delegate creates a subagent, it should NOT have completionPrompt
+    // The subagent is created fresh with only specific options
+    const subagentOptions = {
+      path: process.cwd(),
+      enableDelegate: false, // Prevent recursion
+      disableMermaidValidation: true,
+      disableJsonValidation: true
+      // Note: completionPrompt is NOT passed to subagent
+    };
+
+    const subagent = new ProbeAgent(subagentOptions);
+    expect(subagent.completionPrompt).toBeNull();
+    expect(parentAgent.completionPrompt).toBe('Parent validation prompt');
+  });
+
+  test('should work with clone when both completionPrompt and enableDelegate are set', () => {
+    const baseAgent = new ProbeAgent({
+      completionPrompt: 'Verify response',
+      enableDelegate: true,
+      path: process.cwd()
+    });
+
+    const cloned = baseAgent.clone();
+
+    expect(cloned.completionPrompt).toBe('Verify response');
+    expect(cloned.enableDelegate).toBe(true);
+  });
+});
+
+describe('completionPrompt with validation options', () => {
+  test('should work with disableJsonValidation', () => {
+    const agent = new ProbeAgent({
+      completionPrompt: 'Check JSON output',
+      disableJsonValidation: true,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe('Check JSON output');
+    expect(agent.disableJsonValidation).toBe(true);
+  });
+
+  test('should work with both validation options disabled', () => {
+    const agent = new ProbeAgent({
+      completionPrompt: 'Final review',
+      disableMermaidValidation: true,
+      disableJsonValidation: true,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe('Final review');
+    expect(agent.disableMermaidValidation).toBe(true);
+    expect(agent.disableJsonValidation).toBe(true);
+  });
+
+  test('should preserve all validation options in clone', () => {
+    const baseAgent = new ProbeAgent({
+      completionPrompt: 'Review prompt',
+      disableMermaidValidation: true,
+      disableJsonValidation: true,
+      path: process.cwd()
+    });
+
+    const cloned = baseAgent.clone();
+
+    expect(cloned.completionPrompt).toBe('Review prompt');
+    expect(cloned.disableMermaidValidation).toBe(true);
+    expect(cloned.disableJsonValidation).toBe(true);
+  });
+});
+
+describe('completionPrompt with retry and fallback options', () => {
+  test('should work alongside retry configuration', () => {
+    const agent = new ProbeAgent({
+      completionPrompt: 'Verify with retry enabled',
+      retry: {
+        maxRetries: 3,
+        initialDelay: 1000
+      },
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe('Verify with retry enabled');
+    expect(agent.retryConfig).toEqual({
+      maxRetries: 3,
+      initialDelay: 1000
+    });
+  });
+
+  test('should work alongside fallback configuration', () => {
+    const agent = new ProbeAgent({
+      completionPrompt: 'Review before fallback',
+      fallback: {
+        strategy: 'same-provider'
+      },
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe('Review before fallback');
+    expect(agent.fallbackConfig).toEqual({
+      strategy: 'same-provider'
+    });
+  });
+});
+
+describe('completionPrompt edge cases', () => {
+  test('should handle special characters in completionPrompt', () => {
+    const specialPrompt = 'Review: Check <tags> and "quotes" and \'apostrophes\' and `backticks`';
+    const agent = new ProbeAgent({
+      completionPrompt: specialPrompt,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe(specialPrompt);
+  });
+
+  test('should handle very long completionPrompt', () => {
+    const longPrompt = 'Review the response. '.repeat(100);
+    const agent = new ProbeAgent({
+      completionPrompt: longPrompt,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe(longPrompt);
+    expect(agent.completionPrompt.length).toBeGreaterThan(2000);
+  });
+
+  test('should handle completionPrompt with newlines and formatting', () => {
+    const formattedPrompt = `
+## Review Checklist
+
+1. **Accuracy**: Verify all facts
+2. **Completeness**: Check nothing is missing
+3. **Format**: Ensure proper structure
+
+### Additional Notes
+- Pay attention to edge cases
+- Verify code examples work
+`;
+    const agent = new ProbeAgent({
+      completionPrompt: formattedPrompt,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe(formattedPrompt);
+    expect(agent.completionPrompt).toContain('## Review Checklist');
+    expect(agent.completionPrompt).toContain('**Accuracy**');
+  });
+
+  test('should handle completionPrompt with unicode characters', () => {
+    const unicodePrompt = 'レビュー: 回答を確認してください 🔍 ✅';
+    const agent = new ProbeAgent({
+      completionPrompt: unicodePrompt,
+      path: process.cwd()
+    });
+
+    expect(agent.completionPrompt).toBe(unicodePrompt);
+  });
+});
+
+describe('completionPrompt isolation', () => {
+  test('should not affect other agents when set', () => {
+    const agentWithPrompt = new ProbeAgent({
+      completionPrompt: 'Review this',
+      path: process.cwd()
+    });
+
+    const agentWithoutPrompt = new ProbeAgent({
+      path: process.cwd()
+    });
+
+    expect(agentWithPrompt.completionPrompt).toBe('Review this');
+    expect(agentWithoutPrompt.completionPrompt).toBeNull();
+  });
+
+  test('should allow clearing completionPrompt via clone override', () => {
+    const baseAgent = new ProbeAgent({
+      completionPrompt: 'Original prompt',
+      path: process.cwd()
+    });
+
+    // Note: We can't set to null via override due to || operator, but empty string works
+    const cloned = baseAgent.clone({
+      overrides: {
+        completionPrompt: ''
+      }
+    });
+
+    // Empty string becomes null due to || operator in constructor
+    expect(cloned.completionPrompt).toBeNull();
+    expect(baseAgent.completionPrompt).toBe('Original prompt');
+  });
+});

package/data/probe/npm/tests/unit/cwd-path-options.test.js

@@ -0,0 +1,287 @@
+/**
+ * Tests for cwd/path options in extract, search, and query functions
+ * These tests verify that relative paths are resolved against the specified working directory
+ */
+
+import { extract, search, query } from '../../src/index.js';
+import { validateCwdPath, normalizePath } from '../../src/utils/path-validation.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+// Get the project root directory (where the probe binary can find files)
+const projectRoot = path.resolve(process.cwd(), '..');
+
+describe('cwd/path options for workspace isolation', () => {
+	describe('extract() with cwd option', () => {
+		test('should resolve relative file paths against cwd option', async () => {
+			// Use the project root as the base path
+			const result = await extract({
+				files: ['npm/src/extract.js:1-10'],
+				cwd: projectRoot,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+			// Should successfully extract from the file
+			if (typeof result === 'object') {
+				expect(result.results).toBeDefined();
+			}
+		});
+
+		test('should work with absolute paths regardless of cwd option', async () => {
+			const absolutePath = path.join(projectRoot, 'npm/src/extract.js');
+
+			const result = await extract({
+				files: [`${absolutePath}:1-10`],
+				cwd: os.tmpdir(), // Different cwd, but absolute paths should still work
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should use process.cwd() when cwd is not specified', async () => {
+			// This test verifies default behavior
+			const result = await extract({
+				files: ['src/extract.js:1-10'],
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should handle content with cwd option', async () => {
+			const diffContent = `diff --git a/npm/src/extract.js b/npm/src/extract.js
+index 123..456
+--- a/npm/src/extract.js
++++ b/npm/src/extract.js
+@@ -1,3 +1,4 @@
+ /**
+- * old comment
++ * new comment
+ */`;
+
+			const result = await extract({
+				content: diffContent,
+				cwd: projectRoot,
+				format: 'outline-xml'
+			});
+
+			expect(result).toBeDefined();
+			expect(typeof result).toBe('string');
+		});
+	});
+
+	describe('search() with cwd option', () => {
+		test('should resolve relative search path against cwd option', async () => {
+			const result = await search({
+				query: 'extract',
+				path: 'npm/src',
+				cwd: projectRoot,
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+			if (typeof result === 'object') {
+				expect(result.results).toBeDefined();
+			}
+		});
+
+		test('should work with absolute paths regardless of cwd option', async () => {
+			const absolutePath = path.join(projectRoot, 'npm/src');
+
+			const result = await search({
+				query: 'function',
+				path: absolutePath,
+				cwd: os.tmpdir(), // Different cwd, but absolute paths should still work
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should use process.cwd() when cwd is not specified', async () => {
+			const result = await search({
+				query: 'extract',
+				path: 'src',
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+	});
+
+	describe('query() with cwd option', () => {
+		test('should resolve relative query path against cwd option', async () => {
+			const result = await query({
+				pattern: 'function $NAME($$$ARGS) { $$$BODY }',
+				path: 'npm/src',
+				cwd: projectRoot,
+				language: 'javascript',
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should work with absolute paths regardless of cwd option', async () => {
+			const absolutePath = path.join(projectRoot, 'npm/src');
+
+			const result = await query({
+				pattern: 'function $NAME($$$ARGS) { $$$BODY }',
+				path: absolutePath,
+				cwd: os.tmpdir(), // Different cwd, but absolute paths should still work
+				language: 'javascript',
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should use process.cwd() when cwd is not specified', async () => {
+			const result = await query({
+				pattern: 'function $NAME($$$ARGS) { $$$BODY }',
+				path: 'src',
+				language: 'javascript',
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+	});
+
+	describe('workspace isolation scenario', () => {
+		let tempWorkspace;
+
+		beforeAll(() => {
+			// Create a temporary workspace directory
+			tempWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), 'probe-test-workspace-'));
+
+			// Create a symlink to the npm/src directory in the temp workspace
+			const symlinkPath = path.join(tempWorkspace, 'probe-npm');
+			try {
+				fs.symlinkSync(path.join(projectRoot, 'npm'), symlinkPath);
+			} catch (e) {
+				// Symlink might fail on some systems, skip those tests
+				console.warn('Could not create symlink for test:', e.message);
+			}
+		});
+
+		afterAll(() => {
+			// Clean up temporary workspace
+			if (tempWorkspace && fs.existsSync(tempWorkspace)) {
+				fs.rmSync(tempWorkspace, { recursive: true, force: true });
+			}
+		});
+
+		test('should extract files from workspace using cwd option', async () => {
+			const symlinkPath = path.join(tempWorkspace, 'probe-npm');
+			if (!fs.existsSync(symlinkPath)) {
+				console.warn('Skipping test: symlink not available');
+				return;
+			}
+
+			const result = await extract({
+				files: ['probe-npm/src/extract.js:1-10'],
+				cwd: tempWorkspace,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+
+		test('should search files in workspace using cwd option', async () => {
+			const symlinkPath = path.join(tempWorkspace, 'probe-npm');
+			if (!fs.existsSync(symlinkPath)) {
+				console.warn('Skipping test: symlink not available');
+				return;
+			}
+
+			const result = await search({
+				query: 'extract',
+				path: 'probe-npm/src',
+				cwd: tempWorkspace,
+				maxResults: 5,
+				format: 'json'
+			});
+
+			expect(result).toBeDefined();
+		});
+	});
+
+	describe('path validation security', () => {
+		test('validateCwdPath should normalize paths with .. components', async () => {
+			const basePath = process.cwd();
+			const parentPath = path.dirname(basePath);
+
+			// Path with .. should be normalized
+			const result = await validateCwdPath(path.join(basePath, '..'));
+			expect(result).toBe(parentPath);
+		});
+
+		test('validateCwdPath should return absolute path', async () => {
+			const result = await validateCwdPath('.');
+			expect(path.isAbsolute(result)).toBe(true);
+		});
+
+		test('validateCwdPath should use default when path is not provided', async () => {
+			const result = await validateCwdPath(undefined);
+			expect(result).toBe(path.normalize(process.cwd()));
+		});
+
+		test('validateCwdPath should throw for non-existent path', async () => {
+			await expect(
+				validateCwdPath('/this/path/definitely/does/not/exist/12345')
+			).rejects.toThrow('Path does not exist');
+		});
+
+		test('validateCwdPath should throw for file path (not directory)', async () => {
+			const filePath = path.join(projectRoot, 'npm/package.json');
+			await expect(
+				validateCwdPath(filePath)
+			).rejects.toThrow('Path is not a directory');
+		});
+
+		test('normalizePath should normalize without requiring existence', () => {
+			// Use a path relative to cwd to avoid platform-specific absolute path issues
+			const testPath = path.join('some', 'path', '..', 'normalized');
+			const result = normalizePath(testPath);
+			// Result should be an absolute path containing 'some/normalized' (or 'some\normalized' on Windows)
+			expect(result).toContain(path.join('some', 'normalized'));
+			expect(path.isAbsolute(result)).toBe(true);
+		});
+
+		test('extract should reject non-existent cwd option', async () => {
+			await expect(extract({
+				files: ['some/file.js'],
+				cwd: '/this/path/does/not/exist/12345',
+				format: 'json'
+			})).rejects.toThrow('Path does not exist');
+		});
+
+		test('search should reject non-existent cwd option', async () => {
+			await expect(search({
+				query: 'test',
+				path: '.',
+				cwd: '/this/path/does/not/exist/12345',
+				format: 'json'
+			})).rejects.toThrow('Path does not exist');
+		});
+
+		test('query should reject non-existent cwd option', async () => {
+			await expect(query({
+				pattern: 'function $NAME() {}',
+				path: '.',
+				cwd: '/this/path/does/not/exist/12345',
+				format: 'json'
+			})).rejects.toThrow('Path does not exist');
+		});
+	});
+});