@softerist/heuristic-mcp 2.0.0

package/lib/utils.js

@@ -0,0 +1,301 @@
+import crypto from "crypto";
+import path from "path";
+import { estimateTokens, getChunkingParams, getModelTokenLimit } from "./tokenizer.js";
+
+// Re-export tokenizer utilities
+export { estimateTokens, getChunkingParams, getModelTokenLimit, MODEL_TOKEN_LIMITS } from "./tokenizer.js";
+
+/**
+ * Calculate cosine similarity between two vectors
+ */
+export function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+/**
+ * Fast similarity for normalized vectors (dot product)
+ */
+export function dotSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+
+/**
+ * Generate hash for file content to detect changes
+ */
+export function hashContent(content) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+
+/**
+ * Intelligent chunking with token limit awareness
+ * Tries to split by function/class boundaries while respecting token limits
+ *
+ * @param {string} content - File content to chunk
+ * @param {string} file - File path (for language detection)
+ * @param {object} config - Configuration object with embeddingModel
+ * @returns {Array<{text: string, startLine: number, endLine: number, tokenCount: number}>}
+ */
+export function smartChunk(content, file, config) {
+  const lines = content.split("\n");
+  const chunks = [];
+  const ext = path.extname(file);
+
+  // Get model-specific chunking parameters
+  const { targetTokens, overlapTokens } = getChunkingParams(config.embeddingModel);
+
+  // Language-specific patterns for function/class detection
+  const patterns = {
+    // JavaScript/TypeScript
+    js: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    jsx: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    ts: /^(export\s+)?(async\s+)?(function|class|const|let|var|interface|type)\s+\w+/,
+    tsx: /^(export\s+)?(async\s+)?(function|class|const|let|var|interface|type)\s+\w+/,
+    mjs: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+    cjs: /^(export\s+)?(async\s+)?(function|class|const|let|var)\s+\w+/,
+
+    // Python
+    py: /^(class|def|async\s+def)\s+\w+/,
+    pyw: /^(class|def|async\s+def)\s+\w+/,
+    pyx: /^(cdef|cpdef|def|class)\s+\w+/, // Cython
+
+    // Java/Kotlin/Scala
+    java: /^(public|private|protected)?\s*(static\s+)?(class|interface|enum|void|int|String|boolean)\s+\w+/,
+    kt: /^(class|interface|object|fun|val|var)\s+\w+/,
+    kts: /^(class|interface|object|fun|val|var)\s+\w+/,
+    scala: /^(class|object|trait|def|val|var)\s+\w+/,
+
+    // C/C++
+    c: /^(struct|enum|union|void|int|char|float|double)\s+\w+/,
+    cpp: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    cc: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    cxx: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    h: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    hpp: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+    hxx: /^(class|struct|namespace|template|void|int|bool)\s+\w+/,
+
+    // C#
+    cs: /^(public|private|protected)?\s*(static\s+)?(class|interface|struct|enum|void|int|string|bool)\s+\w+/,
+    csx: /^(public|private|protected)?\s*(static\s+)?(class|interface|struct|enum|void|int|string|bool)\s+\w+/,
+
+    // Go
+    go: /^(func|type|const|var)\s+\w+/,
+
+    // Rust
+    rs: /^(pub\s+)?(fn|struct|enum|trait|impl|const|static|mod)\s+\w+/,
+
+    // PHP
+    php: /^(class|interface|trait|function|const)\s+\w+/,
+    phtml: /^(<\?php|class|interface|trait|function)\s*/,
+
+    // Ruby
+    rb: /^(class|module|def)\s+\w+/,
+    rake: /^(class|module|def|task|namespace)\s+\w+/,
+
+    // Swift
+    swift: /^(class|struct|enum|protocol|func|var|let|extension)\s+\w+/,
+
+    // R
+    r: /^(\w+)\s*(<-|=)\s*function/,
+    R: /^(\w+)\s*(<-|=)\s*function/,
+
+    // Lua
+    lua: /^(function|local\s+function)\s+\w+/,
+
+    // Shell scripts
+    sh: /^(\w+\s*\(\)|function\s+\w+)/,
+    bash: /^(\w+\s*\(\)|function\s+\w+)/,
+    zsh: /^(\w+\s*\(\)|function\s+\w+)/,
+    fish: /^function\s+\w+/,
+
+    // CSS/Styles
+    css: /^(\.|#|@media|@keyframes|@font-face|\w+)\s*[{,]/,
+    scss: /^(\$\w+:|@mixin|@function|@include|\.|#|@media)\s*/,
+    sass: /^(\$\w+:|=\w+|\+\w+|\.|#|@media)\s*/,
+    less: /^(@\w+:|\.|\#|@media)\s*/,
+    styl: /^(\$\w+\s*=|\w+\(|\.|\#)\s*/,
+
+    // Markup/HTML
+    html: /^(<(div|section|article|header|footer|nav|main|aside|form|table|template|script|style)\b)/i,
+    htm: /^(<(div|section|article|header|footer|nav|main|aside|form|table|template|script|style)\b)/i,
+    xml: /^(<\w+|\s*<!\[CDATA\[)/,
+    svg: /^(<svg|<g|<path|<defs|<symbol)\b/,
+
+    // Config files
+    json: /^(\s*"[\w-]+"\s*:\s*[\[{])/,
+    yaml: /^(\w[\w-]*:\s*[|>]?$|\w[\w-]*:\s*$)/,
+    yml: /^(\w[\w-]*:\s*[|>]?$|\w[\w-]*:\s*$)/,
+    toml: /^(\[\[?\w+\]?\]?|\w+\s*=)/,
+    ini: /^(\[\w+\]|\w+\s*=)/,
+    env: /^[A-Z_][A-Z0-9_]*=/,
+
+    // Documentation
+    md: /^(#{1,6}\s+|```|\*{3}|_{3})/,
+    mdx: /^(#{1,6}\s+|```|import\s+|export\s+)/,
+    txt: /^.{50,}/, // Split on long paragraphs
+    rst: /^(={3,}|-{3,}|~{3,}|\.\.\s+\w+::)/,
+
+    // Database
+    sql: /^(CREATE|ALTER|INSERT|UPDATE|DELETE|SELECT|DROP|GRANT|REVOKE|WITH|DECLARE|BEGIN|END)\s+/i,
+
+    // Perl
+    pl: /^(sub|package|use|require)\s+\w+/,
+    pm: /^(sub|package|use|require)\s+\w+/,
+
+    // Vim
+    vim: /^(function|command|autocmd|let\s+g:)\s*/,
+  };
+
+  const langPattern = patterns[ext.slice(1)] || patterns.js;
+  let currentChunk = [];
+  let chunkStartLine = 0;
+  let currentTokenCount = 0;
+
+  // Track bracket depth for better boundary detection
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let inString = false;
+  let inComment = false;
+  let stringChar = null; // ' or " or `
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineTokens = estimateTokens(line);
+    const trimmed = line.trim();
+
+    // Simple state tracking for heuristics (not a full parser)
+    if (inComment) {
+      // Look for end of block comment
+      if (line.includes('*/')) {
+        const parts = line.split('*/');
+        // If there's content after the comment, process it (simplified)
+        if (parts[parts.length - 1].trim().length > 0) {
+           inComment = false;
+           // Recursive call or continue logic would be better, but for heuristic this is fine
+           // We just assume the line is mixed and skip granular checks
+        } else {
+           inComment = false;
+        }
+      }
+    } else {
+      for (let j = 0; j < line.length; j++) {
+        const char = line[j];
+        const nextChar = line[j+1];
+
+        if (inString) {
+          if (char === '\\') {
+            j++; // Skip escaped char
+          } else if (char === stringChar) {
+            inString = false;
+            stringChar = null;
+          }
+        } else {
+          // Check for comment start
+          if (char === '/' && nextChar === '*') {
+            inComment = true;
+            j++;
+            // Check if it ends on same line
+            if (line.indexOf('*/', j) !== -1) {
+              inComment = false;
+              j = line.indexOf('*/', j) + 1;
+            } else {
+              break; // Rest of line is comment
+            }
+          } else if (char === '/' && nextChar === '/') {
+            break; // Skip rest of line (line comment)
+          } else if (char === '\'' || char === '"' || char === '`') {
+            inString = true;
+            stringChar = char;
+          } else {
+            // Only count brackets if not in string or comment
+            if (char === '{') braceDepth++;
+            else if (char === '}') braceDepth = Math.max(0, braceDepth - 1);
+            else if (char === '[') bracketDepth++;
+            else if (char === ']') bracketDepth = Math.max(0, bracketDepth - 1);
+            else if (char === '(') parenDepth++;
+            else if (char === ')') parenDepth = Math.max(0, parenDepth - 1);
+          }
+        }
+      }
+    }
+
+    // Check if adding this line would exceed token limit
+    const wouldExceedLimit = (currentTokenCount + lineTokens) > targetTokens;
+
+    // Check if this is a good split point using multiple heuristics
+    const matchesPattern = langPattern.test(trimmed);
+    const atTopLevel = braceDepth === 0 && bracketDepth === 0 && parenDepth === 0 && !inString && !inComment;
+    const startsAtColumn0 = line.length > 0 && /^\S/.test(line);
+    const isEmptyLine = trimmed.length === 0;
+    const prevWasEmpty = i > 0 && currentChunk.length > 0 && currentChunk[currentChunk.length - 1].trim().length === 0;
+    const isCommentStart = /^\s*(\/\*\*|\/\/\s*[-=]{3,}|#\s*[-=]{3,})/.test(line);
+
+    const isGoodSplitPoint = currentChunk.length > 3 && (
+      (matchesPattern && (atTopLevel || braceDepth <= 1)) ||
+      (atTopLevel && startsAtColumn0 && !isEmptyLine) ||
+      (prevWasEmpty && (matchesPattern || isCommentStart))
+    );
+
+    const shouldSplit = wouldExceedLimit || (isGoodSplitPoint && currentTokenCount > targetTokens * 0.6);
+
+    // Avoid splitting in weird states if possible
+    const safeToSplit = (braceDepth <= 1 && !inString) || wouldExceedLimit;
+
+    if (shouldSplit && safeToSplit && currentChunk.length > 0) {
+      const chunkText = currentChunk.join("\n");
+      if (chunkText.trim().length > 20) {
+        chunks.push({
+          text: chunkText,
+          startLine: chunkStartLine + 1,
+          endLine: i,
+          tokenCount: currentTokenCount
+        });
+      }
+
+      // Calculate overlap
+      let overlapLines = [];
+      let overlapTokensCount = 0;
+      for (let j = currentChunk.length - 1; j >= 0 && overlapTokensCount < overlapTokens; j--) {
+        const lineT = estimateTokens(currentChunk[j]);
+        if (overlapTokensCount + lineT <= overlapTokens) {
+          overlapLines.unshift(currentChunk[j]);
+          overlapTokensCount += lineT;
+        } else {
+          break;
+        }
+      }
+
+      currentChunk = overlapLines;
+      currentTokenCount = overlapTokensCount;
+      chunkStartLine = i - overlapLines.length;
+    }
+
+    currentChunk.push(line);
+    currentTokenCount += lineTokens;
+  }
+
+  // Add remaining chunk
+  if (currentChunk.length > 0) {
+    const chunkText = currentChunk.join("\n");
+    if (chunkText.trim().length > 20) {
+      chunks.push({
+        text: chunkText,
+        startLine: chunkStartLine + 1,
+        endLine: lines.length,
+        tokenCount: currentTokenCount
+      });
+    }
+  }
+
+  return chunks;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@softerist/heuristic-mcp",
+  "version": "2.0.0",
+  "description": "An enhanced MCP server providing intelligent semantic code search with find-similar-code, recency ranking, and improved chunking. Fork of smart-coding-mcp.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "heuristic-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clear-cache": "node scripts/clear-cache.js"
+  },
+  "keywords": [
+    "mcp",
+    "semantic-search",
+    "code-search",
+    "embeddings",
+    "ai",
+    "model-context-protocol",
+    "hybrid-search",
+    "code-intelligence",
+    "cursor",
+    "vscode",
+    "claude",
+    "codex",
+    "openai",
+    "gemini",
+    "anthropic",
+    "antigravity",
+    "heuristic"
+  ],
+  "author": {
+    "name": "Softerist",
+    "url": "https://softerist.com"
+  },
+  "contributors": [
+    {
+      "name": "Omar Haris",
+      "url": "https://www.linkedin.com/in/omarharis/"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/softerist/heuristic-mcp"
+  },
+  "homepage": "https://github.com/softerist/heuristic-mcp#readme",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@xenova/transformers": "^2.17.2",
+    "chokidar": "^3.5.3",
+    "fdir": "^6.5.0",
+    "glob": "^10.3.10"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.16"
+  }
+}

package/scripts/clear-cache.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import fs from "fs/promises";
+import path from "path";
+
+async function clearCache() {
+  try {
+    const configPath = path.join(process.cwd(), "config.json");
+    let cacheDir = "./.smart-coding-cache";
+
+    // Try to load cache directory from config
+    try {
+      const configData = await fs.readFile(configPath, "utf-8");
+      const config = JSON.parse(configData);
+      if (config.cacheDirectory) {
+        cacheDir = path.resolve(config.cacheDirectory);
+      }
+    } catch {
+      console.log("Using default cache directory");
+    }
+
+    // Remove cache directory
+    await fs.rm(cacheDir, { recursive: true, force: true });
+    console.log(`Cache cleared successfully: ${cacheDir}`);
+    console.log("Next startup will perform a full reindex.");
+  } catch (error) {
+    console.error(`Error clearing cache: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+clearCache();

package/test/clear-cache.test.js

@@ -0,0 +1,288 @@
+/**
+ * Tests for CacheClearer feature
+ * 
+ * Tests the cache clearing functionality including:
+ * - Basic cache clearing
+ * - Protection during indexing
+ * - Protection during save operations
+ * - Concurrent clear prevention
+ * - Tool handler responses
+ */
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { 
+  createTestFixtures, 
+  cleanupFixtures, 
+  clearTestCache,
+  createMockRequest 
+} from './helpers.js';
+import * as ClearCacheFeature from '../features/clear-cache.js';
+import { CacheClearer } from '../features/clear-cache.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+describe('CacheClearer', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    // Reset state
+    fixtures.indexer.isIndexing = false;
+    fixtures.cache.isSaving = false;
+    fixtures.cacheClearer.isClearing = false;
+  });
+
+  describe('Basic Cache Clearing', () => {
+    it('should clear cache successfully', async () => {
+      // First ensure we have a cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Verify cache exists
+      expect(fixtures.cache.getVectorStore().length).toBeGreaterThan(0);
+      
+      // Clear cache
+      const result = await fixtures.cacheClearer.execute();
+      
+      expect(result.success).toBe(true);
+      expect(result.message).toContain('Cache cleared successfully');
+      expect(result.cacheDirectory).toBe(fixtures.config.cacheDirectory);
+    });
+    
+    it('should empty vectorStore and fileHashes', async () => {
+      // Create some cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Both should be empty
+      expect(fixtures.cache.getVectorStore().length).toBe(0);
+      expect(fixtures.cache.fileHashes.size).toBe(0);
+    });
+    
+    it('should delete cache directory', async () => {
+      // Create cache
+      await fixtures.indexer.indexAll(true);
+      
+      // Verify cache directory exists
+      await expect(fs.access(fixtures.config.cacheDirectory)).resolves.not.toThrow();
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Directory should not exist
+      await expect(fs.access(fixtures.config.cacheDirectory)).rejects.toThrow();
+    });
+  });
+
+  describe('Protection During Indexing', () => {
+    it('should prevent clear while indexing is in progress', async () => {
+      // Simulate indexing in progress
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      const indexPromise = fixtures.indexer.indexAll(true);
+      
+      // Wait for indexing to start
+      await new Promise(resolve => setTimeout(resolve, 100));
+      expect(fixtures.indexer.isIndexing).toBe(true);
+      
+      // Try to clear - should fail
+      await expect(fixtures.cacheClearer.execute()).rejects.toThrow(
+        'Cannot clear cache while indexing is in progress'
+      );
+      
+      await indexPromise;
+    });
+    
+    it('should allow clear after indexing completes', async () => {
+      // Complete indexing
+      await fixtures.indexer.indexAll(true);
+      expect(fixtures.indexer.isIndexing).toBe(false);
+      
+      // Clear should work
+      const result = await fixtures.cacheClearer.execute();
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Protection During Save', () => {
+    it('should prevent clear while cache is being saved', async () => {
+      // Simulate save in progress
+      fixtures.cache.isSaving = true;
+      
+      // Try to clear - should fail
+      await expect(fixtures.cacheClearer.execute()).rejects.toThrow(
+        'Cannot clear cache while cache is being saved'
+      );
+      
+      // Reset
+      fixtures.cache.isSaving = false;
+    });
+    
+    it('should allow clear after save completes', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      // isSaving should be false after indexing
+      expect(fixtures.cache.isSaving).toBe(false);
+      
+      // Clear should work
+      const result = await fixtures.cacheClearer.execute();
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Concurrent Clear Prevention', () => {
+    it('should prevent multiple concurrent clears', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      // Reset the isClearing flag
+      fixtures.cacheClearer.isClearing = false;
+      
+      // Start multiple concurrent clears
+      const promises = [
+        fixtures.cacheClearer.execute(),
+        fixtures.cacheClearer.execute(),
+        fixtures.cacheClearer.execute()
+      ];
+      
+      const results = await Promise.allSettled(promises);
+      
+      // Exactly one should succeed
+      const successes = results.filter(r => r.status === 'fulfilled');
+      const failures = results.filter(r => r.status === 'rejected');
+      
+      expect(successes.length).toBe(1);
+      expect(failures.length).toBe(2);
+      
+      // Failures should have correct error message
+      for (const failure of failures) {
+        expect(failure.reason.message).toContain('already in progress');
+      }
+    });
+    
+    it('should reset isClearing flag after completion', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+      
+      // Clear
+      await fixtures.cacheClearer.execute();
+      
+      // Flag should be reset
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+    });
+    
+    it('should reset isClearing flag even on error', async () => {
+      // Set up for failure
+      fixtures.cache.isSaving = true;
+      
+      try {
+        await fixtures.cacheClearer.execute();
+      } catch {
+        // Expected to fail
+      }
+      
+      // isClearing should not have been set (failed before setting)
+      expect(fixtures.cacheClearer.isClearing).toBe(false);
+      
+      // Reset
+      fixtures.cache.isSaving = false;
+    });
+  });
+});
+
+describe('Clear Cache Tool Handler', () => {
+  let fixtures;
+  
+  beforeAll(async () => {
+    fixtures = await createTestFixtures({ workerThreads: 2 });
+  });
+  
+  afterAll(async () => {
+    await cleanupFixtures(fixtures);
+  });
+  
+  beforeEach(async () => {
+    fixtures.indexer.isIndexing = false;
+    fixtures.cache.isSaving = false;
+    fixtures.cacheClearer.isClearing = false;
+  });
+
+  describe('Tool Definition', () => {
+    it('should have correct tool definition', () => {
+      const toolDef = ClearCacheFeature.getToolDefinition();
+      
+      expect(toolDef.name).toBe('c_clear_cache');
+      expect(toolDef.description).toContain('cache');
+      expect(toolDef.annotations.destructiveHint).toBe(true);
+      expect(toolDef.inputSchema.properties).toEqual({});
+    });
+  });
+
+  describe('Tool Handler', () => {
+    it('should return success message on cleared cache', async () => {
+      // Index first
+      await fixtures.indexer.indexAll(true);
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Cache cleared successfully');
+      expect(result.content[0].text).toContain('Cache directory:');
+    });
+    
+    it('should return error message when indexing is in progress', async () => {
+      // Simulate indexing
+      await clearTestCache(fixtures.config);
+      fixtures.cache.setVectorStore([]);
+      fixtures.cache.fileHashes = new Map();
+      
+      const indexPromise = fixtures.indexer.indexAll(true);
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('indexing is in progress');
+      
+      await indexPromise;
+    });
+    
+    it('should return error message when save is in progress', async () => {
+      fixtures.cache.isSaving = true;
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('being saved');
+      
+      fixtures.cache.isSaving = false;
+    });
+    
+    it('should return error message when clear is already in progress', async () => {
+      fixtures.cacheClearer.isClearing = true;
+      
+      const request = createMockRequest('c_clear_cache', {});
+      const result = await ClearCacheFeature.handleToolCall(request, fixtures.cacheClearer);
+      
+      expect(result.content[0].text).toContain('Failed to clear cache');
+      expect(result.content[0].text).toContain('already in progress');
+      
+      fixtures.cacheClearer.isClearing = false;
+    });
+  });
+});