List all collections.

Check if text matches any pattern in the list. Args: text: Text to check against patterns patterns: List of glob patterns Re

Extract functions, classes, imports with progressive disclosure.

Parse all chat files for a project.

Print formatted statistics.

Save project configuration.

Save configuration to file.

Scrape a single page using Crawl4AI with concurrency control

Enable or disable Memory Guard globally.

Summarize a complete conversation.

Wait for a Qdrant collection to exist and be ready for operations. Args: qdrant_store: QdrantStore instance collection_name:

Initialize the watcher with required dependencies. Args: repo_path: Path to the repository to watch config: IndexerCo

Add 12.5% overlap between adjacent chunks for context.

Analyze file types in collection based on v2.4 chunk data.

Analyze file with Jedi for semantic information.

Apply Reciprocal Rank Fusion to combine dense and sparse search results. Args: dense_results: Results from dense vector s

Batch get all existing entities in single query

Calculate complexity based on control flow statements.

Calculate cyclomatic complexity (simplified).

Calculate complexity based on control flow statements.

Calculate delay for exponential backoff with jitter.

Pre-calculate document frequencies for all vocabulary terms to avoid O(n²) recalculation.

Call OpenAI API with exponential backoff retry.

Categorize conversation based on content analysis.

Categorize files into new, modified, and deleted.

Categorize vectored files (files with entities in database) into new, modified, and deleted.

Check pending files and process ready ones via callback.

Clean up orphaned relations after successful storage with timer control.

Collect cost data from embedding results.

Check if a collection supports sparse vectors with retry for timing issues. Args: collection_name: Name of the collection

Check if a command exists in PATH.

Convert basic markdown to HTML.

Count manually added entries using comprehensive detection logic.

Create CALLS relations only for project-defined entities.

Split text into chunks by lines.

Create class entity with chunks.

Create searchable chunks from CSS content.

Create implementation and metadata chunks from section group.

Create CALLS relations only for project-defined entities.

Create function entity with metadata and implementation chunks.

Create the pre-commit hook script.

Create searchable chunks from HTML content.

Create import relation from import statement.

Group sections intelligently into token-optimized chunks.

Create TypeScript interface entity.

Create searchable chunks from JSON content.

Create search query from conversation content.

Create prompt for OpenAI summarization.

Create searchable chunks from YAML content.

Deduplicate relations before embedding to save costs.

Delete entities in batch before upsert.

Detect design patterns in class.

Detect primary programming language from code blocks.

Detect the project root directory using Claude-first weighted scoring.

Detect the type of YAML file.

Attempt early project detection from hook data or current directory.

Create all three debug log files if they don't exist.

Extract asynchronous programming patterns.

Extract author information from an item.

Fallback: Extract basic CSS class/ID patterns using regex when tree-sitter fails.

Extract basic topics when OpenAI fails.

Extract class attributes.

Extract CSS class definitions.

Extract class field definitions as variables.

Extract class references for potential CSS relations.

Extract clean content by removing existing overlap markers to prevent cascading.

Extract clean purpose from JSDoc/docstring without parameter clutter.

Extract component-like structures (custom elements, elements with data attributes).

Enhanced content extraction: extract individual posts/articles as separate entities.

Extract content items using streaming JSON parser for large files.

Extract CSS class definitions from inline CSS using CSS parser logic.

Extract CSS ID definitions from inline CSS.

Extract CSS variable definitions from inline CSS.

Extract CSS custom properties (variables).

Extract decorator name from decorator node.

Extract TypeScript decorator relations.

Extract decorators from function or class.

Extract meaningful patterns and content from docstring.

Extract HTML elements that have id attributes.

Extract exception types that are caught/thrown with enhanced pattern recognition.

Extract exception handling relations (try/catch/throw).

Extract exception type from throw statement.

Extract exception types from source code.

Extract file operations from Python AST using tree-sitter.

Extract framework and library usage patterns.

Extract variables from object destructuring patterns. Handles: {name, age}, {username: uname}, nested {address: {street, city}}

Extract meaningful function calls using AST structural heuristics.

Extract function calls using simple pattern matching.

Extract generic YAML structure.

Extract headers, links, and code blocks from Markdown file.

Extract CSS ID definitions.

Extract implementation chunk for function or class with semantic metadata.

Extract full implementation chunks using AST + Jedi for progressive disclosure.

Extract @import relations.

Extract imports referenced in the source code.

Extract inheritance information from class definition.

Extract inheritance relations from a class definition node.

Extract class inheritance relations (extends/implements).

Extract CSS entities from <style> tag content using CSS parser logic.