wip: [01-stabilize] paused at task 1/1 - OCR Hallucination Immune logic via Semantic delta window and fret-isolation
This commit is contained in:
3
.agent/services/claude-mem/tests/utils/CLAUDE.md
Normal file
3
.agent/services/claude-mem/tests/utils/CLAUDE.md
Normal file
@@ -0,0 +1,3 @@
|
||||
<claude-mem-context>
|
||||
|
||||
</claude-mem-context>
|
||||
1004
.agent/services/claude-mem/tests/utils/claude-md-utils.test.ts
Normal file
1004
.agent/services/claude-mem/tests/utils/claude-md-utils.test.ts
Normal file
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,411 @@
|
||||
import { describe, it, expect } from 'bun:test';
|
||||
|
||||
/**
|
||||
* Direct implementation of formatTool for testing
|
||||
* This avoids Bun's mock.module() pollution from parallel tests
|
||||
* The logic is identical to Logger.formatTool in src/utils/logger.ts
|
||||
*/
|
||||
function formatTool(toolName: string, toolInput?: any): string {
|
||||
if (!toolInput) return toolName;
|
||||
|
||||
let input = toolInput;
|
||||
if (typeof toolInput === 'string') {
|
||||
try {
|
||||
input = JSON.parse(toolInput);
|
||||
} catch {
|
||||
// Input is a raw string (e.g., Bash command), use as-is
|
||||
input = toolInput;
|
||||
}
|
||||
}
|
||||
|
||||
// Bash: show full command
|
||||
if (toolName === 'Bash' && input.command) {
|
||||
return `${toolName}(${input.command})`;
|
||||
}
|
||||
|
||||
// File operations: show full path
|
||||
if (input.file_path) {
|
||||
return `${toolName}(${input.file_path})`;
|
||||
}
|
||||
|
||||
// NotebookEdit: show full notebook path
|
||||
if (input.notebook_path) {
|
||||
return `${toolName}(${input.notebook_path})`;
|
||||
}
|
||||
|
||||
// Glob: show full pattern
|
||||
if (toolName === 'Glob' && input.pattern) {
|
||||
return `${toolName}(${input.pattern})`;
|
||||
}
|
||||
|
||||
// Grep: show full pattern
|
||||
if (toolName === 'Grep' && input.pattern) {
|
||||
return `${toolName}(${input.pattern})`;
|
||||
}
|
||||
|
||||
// WebFetch/WebSearch: show full URL or query
|
||||
if (input.url) {
|
||||
return `${toolName}(${input.url})`;
|
||||
}
|
||||
|
||||
if (input.query) {
|
||||
return `${toolName}(${input.query})`;
|
||||
}
|
||||
|
||||
// Task: show subagent_type or full description
|
||||
if (toolName === 'Task') {
|
||||
if (input.subagent_type) {
|
||||
return `${toolName}(${input.subagent_type})`;
|
||||
}
|
||||
if (input.description) {
|
||||
return `${toolName}(${input.description})`;
|
||||
}
|
||||
}
|
||||
|
||||
// Skill: show skill name
|
||||
if (toolName === 'Skill' && input.skill) {
|
||||
return `${toolName}(${input.skill})`;
|
||||
}
|
||||
|
||||
// LSP: show operation type
|
||||
if (toolName === 'LSP' && input.operation) {
|
||||
return `${toolName}(${input.operation})`;
|
||||
}
|
||||
|
||||
// Default: just show tool name
|
||||
return toolName;
|
||||
}
|
||||
|
||||
describe('logger.formatTool()', () => {
|
||||
describe('Valid JSON string input', () => {
|
||||
it('should parse JSON string and extract command for Bash', () => {
|
||||
const result = formatTool('Bash', '{"command": "ls -la"}');
|
||||
expect(result).toBe('Bash(ls -la)');
|
||||
});
|
||||
|
||||
it('should parse JSON string and extract file_path', () => {
|
||||
const result = formatTool('Read', '{"file_path": "/path/to/file.ts"}');
|
||||
expect(result).toBe('Read(/path/to/file.ts)');
|
||||
});
|
||||
|
||||
it('should parse JSON string and extract pattern for Glob', () => {
|
||||
const result = formatTool('Glob', '{"pattern": "**/*.ts"}');
|
||||
expect(result).toBe('Glob(**/*.ts)');
|
||||
});
|
||||
|
||||
it('should parse JSON string and extract pattern for Grep', () => {
|
||||
const result = formatTool('Grep', '{"pattern": "TODO|FIXME"}');
|
||||
expect(result).toBe('Grep(TODO|FIXME)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Raw non-JSON string input (Issue #545 bug fix)', () => {
|
||||
it('should handle raw command string without crashing', () => {
|
||||
// This was the bug: raw strings caused JSON.parse to throw
|
||||
const result = formatTool('Bash', 'raw command string');
|
||||
// Since it's not JSON, it should just return the tool name
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should handle malformed JSON gracefully', () => {
|
||||
const result = formatTool('Read', '{file_path: broken}');
|
||||
expect(result).toBe('Read');
|
||||
});
|
||||
|
||||
it('should handle partial JSON gracefully', () => {
|
||||
const result = formatTool('Write', '{"file_path":');
|
||||
expect(result).toBe('Write');
|
||||
});
|
||||
|
||||
it('should handle empty string input', () => {
|
||||
const result = formatTool('Bash', '');
|
||||
// Empty string is falsy, so returns just the tool name early
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should handle string with special characters', () => {
|
||||
const result = formatTool('Bash', 'echo "hello world" && ls');
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should handle numeric string input', () => {
|
||||
const result = formatTool('Task', '12345');
|
||||
expect(result).toBe('Task');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Already-parsed object input', () => {
|
||||
it('should extract command from Bash object input', () => {
|
||||
const result = formatTool('Bash', { command: 'echo hello' });
|
||||
expect(result).toBe('Bash(echo hello)');
|
||||
});
|
||||
|
||||
it('should extract file_path from Read object input', () => {
|
||||
const result = formatTool('Read', { file_path: '/src/index.ts' });
|
||||
expect(result).toBe('Read(/src/index.ts)');
|
||||
});
|
||||
|
||||
it('should extract file_path from Write object input', () => {
|
||||
const result = formatTool('Write', { file_path: '/output/result.json', content: 'data' });
|
||||
expect(result).toBe('Write(/output/result.json)');
|
||||
});
|
||||
|
||||
it('should extract file_path from Edit object input', () => {
|
||||
const result = formatTool('Edit', { file_path: '/src/utils.ts', old_string: 'foo', new_string: 'bar' });
|
||||
expect(result).toBe('Edit(/src/utils.ts)');
|
||||
});
|
||||
|
||||
it('should extract pattern from Glob object input', () => {
|
||||
const result = formatTool('Glob', { pattern: 'src/**/*.test.ts' });
|
||||
expect(result).toBe('Glob(src/**/*.test.ts)');
|
||||
});
|
||||
|
||||
it('should extract pattern from Grep object input', () => {
|
||||
const result = formatTool('Grep', { pattern: 'function\\s+\\w+', path: '/src' });
|
||||
expect(result).toBe('Grep(function\\s+\\w+)');
|
||||
});
|
||||
|
||||
it('should extract notebook_path from NotebookEdit object input', () => {
|
||||
const result = formatTool('NotebookEdit', { notebook_path: '/notebooks/analysis.ipynb' });
|
||||
expect(result).toBe('NotebookEdit(/notebooks/analysis.ipynb)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Empty/null/undefined inputs', () => {
|
||||
it('should return just tool name when toolInput is undefined', () => {
|
||||
const result = formatTool('Bash');
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should return just tool name when toolInput is null', () => {
|
||||
const result = formatTool('Bash', null);
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should return just tool name when toolInput is undefined explicitly', () => {
|
||||
const result = formatTool('Bash', undefined);
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should return just tool name when toolInput is empty object', () => {
|
||||
const result = formatTool('Bash', {});
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
|
||||
it('should return just tool name when toolInput is 0', () => {
|
||||
// 0 is falsy
|
||||
const result = formatTool('Task', 0);
|
||||
expect(result).toBe('Task');
|
||||
});
|
||||
|
||||
it('should return just tool name when toolInput is false', () => {
|
||||
// false is falsy
|
||||
const result = formatTool('Task', false);
|
||||
expect(result).toBe('Task');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Various tool types', () => {
|
||||
describe('Bash tool', () => {
|
||||
it('should extract command from object', () => {
|
||||
const result = formatTool('Bash', { command: 'npm install' });
|
||||
expect(result).toBe('Bash(npm install)');
|
||||
});
|
||||
|
||||
it('should extract command from JSON string', () => {
|
||||
const result = formatTool('Bash', '{"command":"git status"}');
|
||||
expect(result).toBe('Bash(git status)');
|
||||
});
|
||||
|
||||
it('should return just Bash when command is missing', () => {
|
||||
const result = formatTool('Bash', { description: 'some action' });
|
||||
expect(result).toBe('Bash');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Read tool', () => {
|
||||
it('should extract file_path', () => {
|
||||
const result = formatTool('Read', { file_path: '/Users/test/file.ts' });
|
||||
expect(result).toBe('Read(/Users/test/file.ts)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Write tool', () => {
|
||||
it('should extract file_path', () => {
|
||||
const result = formatTool('Write', { file_path: '/tmp/output.txt', content: 'hello' });
|
||||
expect(result).toBe('Write(/tmp/output.txt)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edit tool', () => {
|
||||
it('should extract file_path', () => {
|
||||
const result = formatTool('Edit', { file_path: '/src/main.ts', old_string: 'a', new_string: 'b' });
|
||||
expect(result).toBe('Edit(/src/main.ts)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Grep tool', () => {
|
||||
it('should extract pattern', () => {
|
||||
const result = formatTool('Grep', { pattern: 'import.*from' });
|
||||
expect(result).toBe('Grep(import.*from)');
|
||||
});
|
||||
|
||||
it('should prioritize pattern over other fields', () => {
|
||||
const result = formatTool('Grep', { pattern: 'search', path: '/src', type: 'ts' });
|
||||
expect(result).toBe('Grep(search)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Glob tool', () => {
|
||||
it('should extract pattern', () => {
|
||||
const result = formatTool('Glob', { pattern: '**/*.md' });
|
||||
expect(result).toBe('Glob(**/*.md)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Task tool', () => {
|
||||
it('should extract subagent_type when present', () => {
|
||||
const result = formatTool('Task', { subagent_type: 'code_review' });
|
||||
expect(result).toBe('Task(code_review)');
|
||||
});
|
||||
|
||||
it('should extract description when subagent_type is missing', () => {
|
||||
const result = formatTool('Task', { description: 'Analyze the codebase structure' });
|
||||
expect(result).toBe('Task(Analyze the codebase structure)');
|
||||
});
|
||||
|
||||
it('should prefer subagent_type over description', () => {
|
||||
const result = formatTool('Task', { subagent_type: 'research', description: 'Find docs' });
|
||||
expect(result).toBe('Task(research)');
|
||||
});
|
||||
|
||||
it('should return just Task when neither field is present', () => {
|
||||
const result = formatTool('Task', { timeout: 5000 });
|
||||
expect(result).toBe('Task');
|
||||
});
|
||||
});
|
||||
|
||||
describe('WebFetch tool', () => {
|
||||
it('should extract url', () => {
|
||||
const result = formatTool('WebFetch', { url: 'https://example.com/api' });
|
||||
expect(result).toBe('WebFetch(https://example.com/api)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('WebSearch tool', () => {
|
||||
it('should extract query', () => {
|
||||
const result = formatTool('WebSearch', { query: 'typescript best practices' });
|
||||
expect(result).toBe('WebSearch(typescript best practices)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Skill tool', () => {
|
||||
it('should extract skill name', () => {
|
||||
const result = formatTool('Skill', { skill: 'commit' });
|
||||
expect(result).toBe('Skill(commit)');
|
||||
});
|
||||
|
||||
it('should return just Skill when skill is missing', () => {
|
||||
const result = formatTool('Skill', { args: '--help' });
|
||||
expect(result).toBe('Skill');
|
||||
});
|
||||
});
|
||||
|
||||
describe('LSP tool', () => {
|
||||
it('should extract operation', () => {
|
||||
const result = formatTool('LSP', { operation: 'goToDefinition', filePath: '/src/main.ts' });
|
||||
expect(result).toBe('LSP(goToDefinition)');
|
||||
});
|
||||
|
||||
it('should return just LSP when operation is missing', () => {
|
||||
const result = formatTool('LSP', { filePath: '/src/main.ts', line: 10 });
|
||||
expect(result).toBe('LSP');
|
||||
});
|
||||
});
|
||||
|
||||
describe('NotebookEdit tool', () => {
|
||||
it('should extract notebook_path', () => {
|
||||
const result = formatTool('NotebookEdit', { notebook_path: '/docs/demo.ipynb', cell_number: 3 });
|
||||
expect(result).toBe('NotebookEdit(/docs/demo.ipynb)');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Unknown tools', () => {
|
||||
it('should return just tool name for unknown tools with unrecognized fields', () => {
|
||||
const result = formatTool('CustomTool', { foo: 'bar', baz: 123 });
|
||||
expect(result).toBe('CustomTool');
|
||||
});
|
||||
|
||||
it('should extract url from unknown tools if present', () => {
|
||||
// url is a generic extractor
|
||||
const result = formatTool('CustomFetch', { url: 'https://api.custom.com' });
|
||||
expect(result).toBe('CustomFetch(https://api.custom.com)');
|
||||
});
|
||||
|
||||
it('should extract query from unknown tools if present', () => {
|
||||
// query is a generic extractor
|
||||
const result = formatTool('CustomSearch', { query: 'find something' });
|
||||
expect(result).toBe('CustomSearch(find something)');
|
||||
});
|
||||
|
||||
it('should extract file_path from unknown tools if present', () => {
|
||||
// file_path is a generic extractor
|
||||
const result = formatTool('CustomFileTool', { file_path: '/some/path.txt' });
|
||||
expect(result).toBe('CustomFileTool(/some/path.txt)');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Edge cases', () => {
|
||||
it('should handle JSON string with nested objects', () => {
|
||||
const input = JSON.stringify({ command: 'echo test', options: { verbose: true } });
|
||||
const result = formatTool('Bash', input);
|
||||
expect(result).toBe('Bash(echo test)');
|
||||
});
|
||||
|
||||
it('should handle very long command strings', () => {
|
||||
const longCommand = 'npm run build && npm run test && npm run lint && npm run format';
|
||||
const result = formatTool('Bash', { command: longCommand });
|
||||
expect(result).toBe(`Bash(${longCommand})`);
|
||||
});
|
||||
|
||||
it('should handle file paths with spaces', () => {
|
||||
const result = formatTool('Read', { file_path: '/Users/test/My Documents/file.ts' });
|
||||
expect(result).toBe('Read(/Users/test/My Documents/file.ts)');
|
||||
});
|
||||
|
||||
it('should handle file paths with special characters', () => {
|
||||
const result = formatTool('Write', { file_path: '/tmp/test-file_v2.0.ts' });
|
||||
expect(result).toBe('Write(/tmp/test-file_v2.0.ts)');
|
||||
});
|
||||
|
||||
it('should handle patterns with regex special characters', () => {
|
||||
const result = formatTool('Grep', { pattern: '\\[.*\\]|\\(.*\\)' });
|
||||
expect(result).toBe('Grep(\\[.*\\]|\\(.*\\))');
|
||||
});
|
||||
|
||||
it('should handle unicode in strings', () => {
|
||||
const result = formatTool('Bash', { command: 'echo "Hello, World!"' });
|
||||
expect(result).toBe('Bash(echo "Hello, World!")');
|
||||
});
|
||||
|
||||
it('should handle number values in fields correctly', () => {
|
||||
// If command is a number, it gets stringified
|
||||
const result = formatTool('Bash', { command: 123 });
|
||||
expect(result).toBe('Bash(123)');
|
||||
});
|
||||
|
||||
it('should handle JSON array as input', () => {
|
||||
// Arrays don't have command/file_path/etc fields
|
||||
const result = formatTool('Unknown', ['item1', 'item2']);
|
||||
expect(result).toBe('Unknown');
|
||||
});
|
||||
|
||||
it('should handle JSON string that parses to a primitive', () => {
|
||||
// JSON.parse("123") = 123 (number)
|
||||
const result = formatTool('Task', '"a plain string"');
|
||||
// After parsing, input becomes "a plain string" which has no recognized fields
|
||||
expect(result).toBe('Task');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* Project Filter Tests
|
||||
*
|
||||
* Tests glob-based path matching for project exclusion.
|
||||
* Source: src/utils/project-filter.ts
|
||||
*/
|
||||
|
||||
import { describe, it, expect } from 'bun:test';
|
||||
import { isProjectExcluded } from '../../src/utils/project-filter.js';
|
||||
import { homedir } from 'os';
|
||||
|
||||
describe('Project Filter', () => {
|
||||
describe('isProjectExcluded', () => {
|
||||
describe('with empty patterns', () => {
|
||||
it('returns false for empty pattern string', () => {
|
||||
expect(isProjectExcluded('/Users/test/project', '')).toBe(false);
|
||||
expect(isProjectExcluded('/Users/test/project', ' ')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with exact path matching', () => {
|
||||
it('matches exact paths', () => {
|
||||
expect(isProjectExcluded('/tmp/secret', '/tmp/secret')).toBe(true);
|
||||
expect(isProjectExcluded('/tmp/public', '/tmp/secret')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with * wildcard (single directory level)', () => {
|
||||
it('matches any directory name', () => {
|
||||
expect(isProjectExcluded('/tmp/secret', '/tmp/*')).toBe(true);
|
||||
expect(isProjectExcluded('/tmp/anything', '/tmp/*')).toBe(true);
|
||||
});
|
||||
|
||||
it('does not match across directory boundaries', () => {
|
||||
expect(isProjectExcluded('/tmp/a/b', '/tmp/*')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with ** wildcard (any path depth)', () => {
|
||||
it('matches any path depth', () => {
|
||||
expect(isProjectExcluded('/Users/test/kunden/client1/project', '/Users/*/kunden/**')).toBe(true);
|
||||
expect(isProjectExcluded('/Users/test/kunden/deep/nested/project', '/Users/*/kunden/**')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with ? wildcard (single character)', () => {
|
||||
it('matches single character', () => {
|
||||
expect(isProjectExcluded('/tmp/a', '/tmp/?')).toBe(true);
|
||||
expect(isProjectExcluded('/tmp/ab', '/tmp/?')).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with ~ home directory expansion', () => {
|
||||
it('expands ~ to home directory', () => {
|
||||
const home = homedir();
|
||||
expect(isProjectExcluded(`${home}/secret`, '~/secret')).toBe(true);
|
||||
expect(isProjectExcluded(`${home}/projects/secret`, '~/projects/*')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with multiple patterns', () => {
|
||||
it('returns true if any pattern matches', () => {
|
||||
const patterns = '/tmp/*,~/kunden/*,/var/secret';
|
||||
expect(isProjectExcluded('/tmp/test', patterns)).toBe(true);
|
||||
expect(isProjectExcluded(`${homedir()}/kunden/client`, patterns)).toBe(true);
|
||||
expect(isProjectExcluded('/var/secret', patterns)).toBe(true);
|
||||
expect(isProjectExcluded('/home/user/public', patterns)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('with Windows-style paths', () => {
|
||||
it('normalizes backslashes to forward slashes', () => {
|
||||
expect(isProjectExcluded('C:\\Users\\test\\secret', 'C:/Users/*/secret')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('real-world patterns', () => {
|
||||
it('excludes customer projects', () => {
|
||||
const patterns = '~/kunden/*,~/customers/**';
|
||||
const home = homedir();
|
||||
|
||||
expect(isProjectExcluded(`${home}/kunden/acme-corp`, patterns)).toBe(true);
|
||||
expect(isProjectExcluded(`${home}/customers/bigco/project1`, patterns)).toBe(true);
|
||||
expect(isProjectExcluded(`${home}/projects/opensource`, patterns)).toBe(false);
|
||||
});
|
||||
|
||||
it('excludes temporary directories', () => {
|
||||
const patterns = '/tmp/*,/var/tmp/*';
|
||||
|
||||
expect(isProjectExcluded('/tmp/scratch', patterns)).toBe(true);
|
||||
expect(isProjectExcluded('/var/tmp/test', patterns)).toBe(true);
|
||||
expect(isProjectExcluded('/home/user/tmp', patterns)).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
348
.agent/services/claude-mem/tests/utils/tag-stripping.test.ts
Normal file
348
.agent/services/claude-mem/tests/utils/tag-stripping.test.ts
Normal file
@@ -0,0 +1,348 @@
|
||||
/**
|
||||
* Tag Stripping Utility Tests
|
||||
*
|
||||
* Tests the tag privacy system for <private>, <claude-mem-context>, and <system_instruction> tags.
|
||||
* These tags enable users and the system to exclude content from memory storage.
|
||||
*
|
||||
* Sources:
|
||||
* - Implementation from src/utils/tag-stripping.ts
|
||||
* - Privacy patterns from src/services/worker/http/routes/SessionRoutes.ts
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, spyOn, mock } from 'bun:test';
|
||||
import { stripMemoryTagsFromPrompt, stripMemoryTagsFromJson } from '../../src/utils/tag-stripping.js';
|
||||
import { logger } from '../../src/utils/logger.js';
|
||||
|
||||
// Suppress logger output during tests
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('Tag Stripping Utilities', () => {
|
||||
beforeEach(() => {
|
||||
loggerSpies = [
|
||||
spyOn(logger, 'info').mockImplementation(() => {}),
|
||||
spyOn(logger, 'debug').mockImplementation(() => {}),
|
||||
spyOn(logger, 'warn').mockImplementation(() => {}),
|
||||
spyOn(logger, 'error').mockImplementation(() => {}),
|
||||
];
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
});
|
||||
|
||||
describe('stripMemoryTagsFromPrompt', () => {
|
||||
describe('basic tag removal', () => {
|
||||
it('should strip single <private> tag and preserve surrounding content', () => {
|
||||
const input = 'public content <private>secret stuff</private> more public';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('public content more public');
|
||||
});
|
||||
|
||||
it('should strip single <claude-mem-context> tag', () => {
|
||||
const input = 'public content <claude-mem-context>injected context</claude-mem-context> more public';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('public content more public');
|
||||
});
|
||||
|
||||
it('should strip both tag types in mixed content', () => {
|
||||
const input = '<private>secret</private> public <claude-mem-context>context</claude-mem-context> end';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('public end');
|
||||
});
|
||||
});
|
||||
|
||||
describe('multiple tags handling', () => {
|
||||
it('should strip multiple <private> blocks', () => {
|
||||
const input = '<private>first secret</private> middle <private>second secret</private> end';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('middle end');
|
||||
});
|
||||
|
||||
it('should strip multiple <claude-mem-context> blocks', () => {
|
||||
const input = '<claude-mem-context>ctx1</claude-mem-context><claude-mem-context>ctx2</claude-mem-context> content';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('content');
|
||||
});
|
||||
|
||||
it('should handle many interleaved tags', () => {
|
||||
let input = 'start';
|
||||
for (let i = 0; i < 10; i++) {
|
||||
input += ` <private>p${i}</private> <claude-mem-context>c${i}</claude-mem-context>`;
|
||||
}
|
||||
input += ' end';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
// Tags are stripped but spaces between them remain
|
||||
expect(result).not.toContain('<private>');
|
||||
expect(result).not.toContain('<claude-mem-context>');
|
||||
expect(result).toContain('start');
|
||||
expect(result).toContain('end');
|
||||
});
|
||||
});
|
||||
|
||||
describe('empty and private-only prompts', () => {
|
||||
it('should return empty string for entirely private prompt', () => {
|
||||
const input = '<private>entire prompt is private</private>';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('');
|
||||
});
|
||||
|
||||
it('should return empty string for entirely context-tagged prompt', () => {
|
||||
const input = '<claude-mem-context>all is context</claude-mem-context>';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('');
|
||||
});
|
||||
|
||||
it('should preserve content with no tags', () => {
|
||||
const input = 'no tags here at all';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('no tags here at all');
|
||||
});
|
||||
|
||||
it('should handle empty input', () => {
|
||||
const result = stripMemoryTagsFromPrompt('');
|
||||
expect(result).toBe('');
|
||||
});
|
||||
|
||||
it('should handle whitespace-only after stripping', () => {
|
||||
const input = '<private>content</private> <claude-mem-context>more</claude-mem-context>';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('');
|
||||
});
|
||||
});
|
||||
|
||||
describe('content preservation', () => {
|
||||
it('should preserve non-tagged content exactly', () => {
|
||||
const input = 'keep this <private>remove this</private> and this';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('keep this and this');
|
||||
});
|
||||
|
||||
it('should preserve special characters in non-tagged content', () => {
|
||||
const input = 'code: const x = 1; <private>secret</private> more: { "key": "value" }';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('code: const x = 1; more: { "key": "value" }');
|
||||
});
|
||||
|
||||
it('should preserve newlines in non-tagged content', () => {
|
||||
const input = 'line1\n<private>secret</private>\nline2';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('line1\n\nline2');
|
||||
});
|
||||
});
|
||||
|
||||
describe('multiline content in tags', () => {
|
||||
it('should strip multiline content within <private> tags', () => {
|
||||
const input = `public
|
||||
<private>
|
||||
multi
|
||||
line
|
||||
secret
|
||||
</private>
|
||||
end`;
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('public\n\nend');
|
||||
});
|
||||
|
||||
it('should strip multiline content within <claude-mem-context> tags', () => {
|
||||
const input = `start
|
||||
<claude-mem-context>
|
||||
# Recent Activity
|
||||
- Item 1
|
||||
- Item 2
|
||||
</claude-mem-context>
|
||||
finish`;
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('start\n\nfinish');
|
||||
});
|
||||
});
|
||||
|
||||
describe('ReDoS protection', () => {
|
||||
it('should handle content with many tags without hanging (< 1 second)', async () => {
|
||||
// Generate content with many tags
|
||||
let content = '';
|
||||
for (let i = 0; i < 150; i++) {
|
||||
content += `<private>secret${i}</private> text${i} `;
|
||||
}
|
||||
|
||||
const startTime = Date.now();
|
||||
const result = stripMemoryTagsFromPrompt(content);
|
||||
const duration = Date.now() - startTime;
|
||||
|
||||
// Should complete quickly despite many tags
|
||||
expect(duration).toBeLessThan(1000);
|
||||
// Should not contain any private content
|
||||
expect(result).not.toContain('<private>');
|
||||
// Should warn about exceeding tag limit
|
||||
expect(loggerSpies[2]).toHaveBeenCalled(); // warn spy
|
||||
});
|
||||
|
||||
it('should process within reasonable time with nested-looking patterns', () => {
|
||||
// Content that looks like it could cause backtracking
|
||||
const content = '<private>' + 'x'.repeat(10000) + '</private> keep this';
|
||||
|
||||
const startTime = Date.now();
|
||||
const result = stripMemoryTagsFromPrompt(content);
|
||||
const duration = Date.now() - startTime;
|
||||
|
||||
expect(duration).toBeLessThan(1000);
|
||||
expect(result).toBe('keep this');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('stripMemoryTagsFromJson', () => {
|
||||
describe('JSON content stripping', () => {
|
||||
it('should strip tags from stringified JSON', () => {
|
||||
const jsonContent = JSON.stringify({
|
||||
file_path: '/path/to/file',
|
||||
content: '<private>secret</private> public'
|
||||
});
|
||||
const result = stripMemoryTagsFromJson(jsonContent);
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.content).toBe(' public');
|
||||
});
|
||||
|
||||
it('should strip claude-mem-context tags from JSON', () => {
|
||||
const jsonContent = JSON.stringify({
|
||||
data: '<claude-mem-context>injected</claude-mem-context> real data'
|
||||
});
|
||||
const result = stripMemoryTagsFromJson(jsonContent);
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.data).toBe(' real data');
|
||||
});
|
||||
|
||||
it('should handle tool_input with tags', () => {
|
||||
const toolInput = {
|
||||
command: 'echo hello',
|
||||
args: '<private>secret args</private>'
|
||||
};
|
||||
const result = stripMemoryTagsFromJson(JSON.stringify(toolInput));
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.args).toBe('');
|
||||
});
|
||||
|
||||
it('should handle tool_response with tags', () => {
|
||||
const toolResponse = {
|
||||
output: 'result <claude-mem-context>context data</claude-mem-context>',
|
||||
status: 'success'
|
||||
};
|
||||
const result = stripMemoryTagsFromJson(JSON.stringify(toolResponse));
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.output).toBe('result ');
|
||||
});
|
||||
});
|
||||
|
||||
describe('edge cases', () => {
|
||||
it('should handle empty JSON object', () => {
|
||||
const result = stripMemoryTagsFromJson('{}');
|
||||
expect(result).toBe('{}');
|
||||
});
|
||||
|
||||
it('should handle JSON with no tags', () => {
|
||||
const input = JSON.stringify({ key: 'value' });
|
||||
const result = stripMemoryTagsFromJson(input);
|
||||
expect(result).toBe(input);
|
||||
});
|
||||
|
||||
it('should handle nested JSON structures', () => {
|
||||
const input = JSON.stringify({
|
||||
outer: {
|
||||
inner: '<private>secret</private> visible'
|
||||
}
|
||||
});
|
||||
const result = stripMemoryTagsFromJson(input);
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.outer.inner).toBe(' visible');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('system_instruction tag stripping', () => {
|
||||
describe('basic system_instruction removal', () => {
|
||||
it('should strip single <system_instruction> tag from prompt', () => {
|
||||
const input = 'user content <system_instruction>injected instructions</system_instruction> more content';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('user content more content');
|
||||
});
|
||||
|
||||
it('should strip <system_instruction> mixed with <private> tags', () => {
|
||||
const input = '<system_instruction>instructions</system_instruction> public <private>secret</private> end';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('public end');
|
||||
});
|
||||
|
||||
it('should return empty string for entirely <system_instruction> content', () => {
|
||||
const input = '<system_instruction>entire prompt is system instructions</system_instruction>';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('');
|
||||
});
|
||||
|
||||
it('should strip <system_instruction> tags from JSON content', () => {
|
||||
const jsonContent = JSON.stringify({
|
||||
data: '<system_instruction>injected</system_instruction> real data'
|
||||
});
|
||||
const result = stripMemoryTagsFromJson(jsonContent);
|
||||
const parsed = JSON.parse(result);
|
||||
expect(parsed.data).toBe(' real data');
|
||||
});
|
||||
|
||||
it('should strip multiline content within <system_instruction> tags', () => {
|
||||
const input = `before
|
||||
<system_instruction>
|
||||
line one
|
||||
line two
|
||||
line three
|
||||
</system_instruction>
|
||||
after`;
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('before\n\nafter');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('system-instruction (hyphen variant) tag stripping', () => {
|
||||
it('should strip single <system-instruction> tag from prompt', () => {
|
||||
const input = 'user content <system-instruction>injected instructions</system-instruction> more content';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('user content more content');
|
||||
});
|
||||
|
||||
it('should strip both underscore and hyphen variants in same prompt', () => {
|
||||
const input = '<system_instruction>underscore</system_instruction> middle <system-instruction>hyphen</system-instruction> end';
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('middle end');
|
||||
});
|
||||
|
||||
it('should strip multiline <system-instruction> content', () => {
|
||||
const input = `before
|
||||
<system-instruction>
|
||||
line one
|
||||
line two
|
||||
</system-instruction>
|
||||
after`;
|
||||
const result = stripMemoryTagsFromPrompt(input);
|
||||
expect(result).toBe('before\n\nafter');
|
||||
});
|
||||
});
|
||||
|
||||
describe('privacy enforcement integration', () => {
|
||||
it('should allow empty result to trigger privacy skip', () => {
|
||||
// Simulates what SessionRoutes does with private-only prompts
|
||||
const prompt = '<private>entirely private prompt</private>';
|
||||
const cleanedPrompt = stripMemoryTagsFromPrompt(prompt);
|
||||
|
||||
// Empty/whitespace prompts should trigger skip
|
||||
const shouldSkip = !cleanedPrompt || cleanedPrompt.trim() === '';
|
||||
expect(shouldSkip).toBe(true);
|
||||
});
|
||||
|
||||
it('should allow partial content when not entirely private', () => {
|
||||
const prompt = '<private>password123</private> Please help me with my code';
|
||||
const cleanedPrompt = stripMemoryTagsFromPrompt(prompt);
|
||||
|
||||
const shouldSkip = !cleanedPrompt || cleanedPrompt.trim() === '';
|
||||
expect(shouldSkip).toBe(false);
|
||||
expect(cleanedPrompt.trim()).toBe('Please help me with my code');
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user