raggrep 0.1.3 → 0.1.4

package/dist/{utils/config.d.ts → infrastructure/config/configLoader.d.ts}

@@ -1,12 +1,15 @@
 /**
- * Configuration utilities
+ * Configuration Loader
  *
- * Provides functions for loading, saving, and managing RAGgrep configuration.
+ * Infrastructure adapter for loading and saving RAGgrep configuration.
+ * Handles file I/O operations for configuration management.
  */
-import type { Config, ModuleConfig } from '../domain/entities';
-import { EmbeddingConfig } from './embeddings';
+import type { Config, ModuleConfig } from "../../domain/entities";
+import type { EmbeddingConfig, EmbeddingModelName } from "../../domain/ports";
 /** Default configuration instance */
 export declare const DEFAULT_CONFIG: Config;
+/** Available embedding models (for validation) */
+export declare const EMBEDDING_MODELS: Record<EmbeddingModelName, string>;
 /**
  * Get the root .raggrep directory path
  */

package/dist/infrastructure/config/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Configuration Infrastructure
+ *
+ * Handles loading and saving RAGgrep configuration from the filesystem.
+ */
+export { DEFAULT_CONFIG, EMBEDDING_MODELS, getRaggrepDir, getModuleIndexPath, getModuleManifestPath, getGlobalManifestPath, getConfigPath, loadConfig, saveConfig, getModuleConfig, getEmbeddingConfigFromModule, } from "./configLoader";

package/dist/infrastructure/embeddings/index.d.ts

@@ -1,4 +1,6 @@
 /**
  * Embedding Infrastructure
+ *
+ * Provides embedding generation using Transformers.js.
  */
-export { TransformersEmbeddingProvider, EMBEDDING_MODELS, getCacheDir, isModelCached } from './transformersEmbedding';
+export { TransformersEmbeddingProvider, EMBEDDING_MODELS, getCacheDir, isModelCached, configureEmbeddings, getEmbeddingConfig, getEmbedding, getEmbeddings, } from "./transformersEmbedding";

package/dist/infrastructure/embeddings/transformersEmbedding.d.ts

@@ -32,3 +32,19 @@ export declare function getCacheDir(): string;
  * Check if a model is already cached
  */
 export declare function isModelCached(model: EmbeddingModelName): Promise<boolean>;
+/**
+ * Configure the global embedding provider.
+ */
+export declare function configureEmbeddings(config: Partial<EmbeddingConfig>): void;
+/**
+ * Get current embedding configuration.
+ */
+export declare function getEmbeddingConfig(): EmbeddingConfig;
+/**
+ * Get embedding for a single text using the global provider.
+ */
+export declare function getEmbedding(text: string): Promise<number[]>;
+/**
+ * Get embeddings for multiple texts using the global provider.
+ */
+export declare function getEmbeddings(texts: string[]): Promise<number[][]>;

package/dist/infrastructure/index.d.ts

@@ -4,6 +4,7 @@
  * Contains adapters that implement domain ports.
  * These connect the domain to external systems (filesystem, ML models, etc.)
  */
-export { NodeFileSystem, nodeFileSystem } from './filesystem';
-export { TransformersEmbeddingProvider, EMBEDDING_MODELS, getCacheDir, isModelCached } from './embeddings';
-export { FileIndexStorage } from './storage';
+export { NodeFileSystem, nodeFileSystem } from "./filesystem";
+export { TransformersEmbeddingProvider, getCacheDir, isModelCached, } from "./embeddings";
+export { FileIndexStorage, SymbolicIndex, getSymbolicPath } from "./storage";
+export { DEFAULT_CONFIG, EMBEDDING_MODELS, getRaggrepDir, getModuleIndexPath, getModuleManifestPath, getGlobalManifestPath, getConfigPath, loadConfig, saveConfig, getModuleConfig, getEmbeddingConfigFromModule, } from "./config";

package/dist/infrastructure/storage/index.d.ts

@@ -1,4 +1,7 @@
 /**
  * Storage Infrastructure
+ *
+ * Handles persistence of index data to the filesystem.
  */
-export { FileIndexStorage } from './fileIndexStorage';
+export { FileIndexStorage } from "./fileIndexStorage";
+export { SymbolicIndex, getSymbolicPath } from "./symbolicIndex";

package/dist/{utils/tieredIndex.d.ts → infrastructure/storage/symbolicIndex.d.ts}

@@ -1,25 +1,15 @@
 /**
- * Symbolic Index System
+ * Symbolic Index Storage
  *
- * Provides fast keyword-based filtering using BM25 before semantic search.
+ * Manages the keyword-based index for fast file filtering.
+ * Handles file I/O for persisting index data.
  *
  * Structure:
  *   .raggrep/index/<module>/symbolic/
  *   ├── _meta.json    (BM25 statistics)
  *   └── <filepath>.json (per-file summaries)
- *
- * This approach scales well because:
- * - Each file summary is stored separately
- * - BM25 metadata is small and loads quickly
- * - Summaries are loaded on-demand during search
  */
-import type { FileSummary, SymbolicIndexMeta } from '../domain/entities';
-export type { FileSummary, SymbolicIndexMeta } from '../domain/entities';
-export { extractKeywords } from '../domain/services/keywords';
-/** @deprecated Use SymbolicIndexMeta */
-export type Tier1Manifest = SymbolicIndexMeta & {
-    files: Record<string, FileSummary>;
-};
+import type { FileSummary } from "../../domain/entities";
 /**
  * Symbolic Index Manager
  *
@@ -93,8 +83,7 @@ export declare class SymbolicIndex {
      */
     clear(): void;
 }
-/** @deprecated Use SymbolicIndex instead */
-export declare const Tier1Index: typeof SymbolicIndex;
-/** @deprecated Use SymbolicIndex instead */
-export declare function getTier1Path(rootDir: string, moduleId: string, indexDir?: string): string;
+/**
+ * Get the symbolic index path for a module
+ */
 export declare function getSymbolicPath(rootDir: string, moduleId: string, indexDir?: string): string;

package/dist/introspection/fileIntrospector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * File Introspection
+ *
+ * Extracts metadata from individual files for context-aware search.
+ */
+import type { FileIntrospection, ProjectStructure } from "./types";
+/**
+ * Extract introspection metadata for a file.
+ */
+export declare function introspectFile(filepath: string, structure: ProjectStructure, fileContent?: string): FileIntrospection;
+/**
+ * Extract keywords from introspection for search boosting.
+ */
+export declare function introspectionToKeywords(intro: FileIntrospection): string[];

package/dist/introspection/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Introspection Module
+ *
+ * Manages file metadata for context-aware search boosting.
+ */
+import type { FileIntrospection, ProjectStructure } from "./types";
+import type { Config } from "../domain/entities";
+export type { FileIntrospection, ProjectStructure, Project, Scope, ProjectType } from "./types";
+export { introspectFile, introspectionToKeywords } from "./fileIntrospector";
+export { detectProjectStructure, detectScopeFromName } from "./projectDetector";
+/**
+ * Introspection index for a workspace.
+ */
+export declare class IntrospectionIndex {
+    private rootDir;
+    private structure;
+    private files;
+    private config;
+    constructor(rootDir: string);
+    /**
+     * Initialize by detecting project structure.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get project structure.
+     */
+    getStructure(): ProjectStructure | null;
+    /**
+     * Introspect a file and add to index.
+     */
+    addFile(filepath: string, content?: string): FileIntrospection;
+    /**
+     * Get introspection for a file.
+     */
+    getFile(filepath: string): FileIntrospection | undefined;
+    /**
+     * Get all introspected files.
+     */
+    getAllFiles(): FileIntrospection[];
+    /**
+     * Apply config overrides to introspection.
+     */
+    private applyOverrides;
+    /**
+     * Save introspection index to disk.
+     */
+    save(config: Config): Promise<void>;
+    /**
+     * Load introspection index from disk.
+     */
+    load(config: Config): Promise<void>;
+    /**
+     * Recursively load file introspections.
+     */
+    private loadFilesRecursive;
+    /**
+     * Clear the index.
+     */
+    clear(): void;
+}
+/**
+ * Calculate search boost based on introspection and query.
+ *
+ * @param intro - File introspection
+ * @param query - Search query
+ * @returns Boost multiplier (1.0 = no boost, >1.0 = positive boost)
+ */
+export declare function calculateIntrospectionBoost(intro: FileIntrospection, query: string): number;

package/dist/introspection/introspection.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Introspection Module
+ */
+export {};

package/dist/introspection/projectDetector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Project Structure Detection
+ *
+ * Auto-detects monorepo structure and project types from:
+ * - Folder layout (apps/, packages/, etc.)
+ * - package.json files (for TypeScript/JavaScript projects)
+ */
+import type { Project, ProjectStructure, Scope } from "./types";
+/**
+ * Detect scope from project name.
+ */
+export declare function detectScopeFromName(name: string): Scope;
+/**
+ * Detect project structure in a workspace.
+ *
+ * Uses two strategies:
+ * 1. Folder pattern detection (apps/, packages/, etc.)
+ * 2. package.json scanning for more accurate project boundaries
+ */
+export declare function detectProjectStructure(rootDir: string): Promise<ProjectStructure>;
+/**
+ * Find which project a file belongs to.
+ *
+ * Matches against detected projects (from package.json and folder patterns).
+ * For nested projects, returns the most specific (deepest) match.
+ */
+export declare function findProjectForFile(filepath: string, structure: ProjectStructure): Project;

package/dist/introspection/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Introspection Types
+ *
+ * Shared metadata extracted from file paths and project structure.
+ * Used by all index modules for context-aware scoring.
+ */
+/**
+ * Project type detected from folder structure.
+ */
+export type ProjectType = "app" | "library" | "service" | "script" | "unknown";
+/**
+ * Scope of the file in the overall system.
+ */
+export type Scope = "frontend" | "backend" | "shared" | "tooling" | "unknown";
+/**
+ * Detected project within a monorepo.
+ */
+export interface Project {
+    /** Project name (from folder or package.json) */
+    name: string;
+    /** Root path relative to workspace */
+    root: string;
+    /** Detected project type */
+    type: ProjectType;
+}
+/**
+ * File introspection metadata.
+ * Computed once during indexing, used for search boosting.
+ */
+export interface FileIntrospection {
+    /** File path relative to workspace */
+    filepath: string;
+    /** Project context (from folder structure or package.json) */
+    project: Project;
+    /** Scope detection (frontend, backend, shared, tooling) */
+    scope: Scope;
+    /** Architectural layer (controller, service, repository, etc.) */
+    layer?: string;
+    /** Feature domain (auth, users, payments, etc.) */
+    domain?: string;
+    /** Detected programming language */
+    language: string;
+    /** Detected framework (nextjs, express, fastify, etc.) */
+    framework?: string;
+    /** Path depth from workspace root */
+    depth: number;
+    /** Path segments for keyword matching */
+    pathSegments: string[];
+}
+/**
+ * Project structure metadata.
+ */
+export interface ProjectStructure {
+    /** Detected projects in the workspace */
+    projects: Project[];
+    /** Is this a monorepo? */
+    isMonorepo: boolean;
+    /** Root project type (if single project) */
+    rootType?: ProjectType;
+}
+/**
+ * Introspection configuration overrides.
+ */
+export interface IntrospectionConfig {
+    /** Manual project scope overrides */
+    projects?: Record<string, {
+        scope?: Scope;
+        framework?: string;
+    }>;
+}

package/dist/modules/core/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Core Index Module
+ *
+ * Language-agnostic text search using:
+ * - Regex-based symbol extraction
+ * - BM25 keyword matching
+ * - Line-based chunking
+ *
+ * Index location: .raggrep/index/core/
+ *
+ * This module provides fast, deterministic search without embeddings.
+ * It complements language-specific modules by catching symbol matches.
+ */
+import { IndexModule, IndexContext, SearchContext, SearchOptions } from "../../types";
+import type { FileIndex, SearchResult, ModuleConfig } from "../../domain/entities";
+import { type ExtractedSymbol } from "./symbols";
+/**
+ * Core module-specific data stored with file index
+ */
+export interface CoreModuleData {
+    /** Extracted symbols */
+    symbols: ExtractedSymbol[];
+    /** BM25 tokens for this file */
+    tokens: string[];
+    [key: string]: unknown;
+}
+export declare class CoreModule implements IndexModule {
+    readonly id = "core";
+    readonly name = "Core Search";
+    readonly description = "Language-agnostic text search with symbol extraction";
+    readonly version = "1.0.0";
+    private symbolIndex;
+    private bm25Index;
+    private rootDir;
+    initialize(_config: ModuleConfig): Promise<void>;
+    /**
+     * Index a single file.
+     */
+    indexFile(filepath: string, content: string, ctx: IndexContext): Promise<FileIndex | null>;
+    /**
+     * Create line-based chunks from content.
+     */
+    private createChunks;
+    /**
+     * Convert symbol type to chunk type.
+     */
+    private symbolTypeToChunkType;
+    /**
+     * Finalize indexing - build BM25 index and save symbol index.
+     */
+    finalize(ctx: IndexContext): Promise<void>;
+    /**
+     * Search the index.
+     */
+    search(query: string, ctx: SearchContext, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Find symbol name matches for query tokens.
+     */
+    private findSymbolMatches;
+    /**
+     * Find the best matching chunk based on query tokens.
+     */
+    private findBestChunk;
+    /**
+     * Load the symbol index from disk.
+     */
+    private loadSymbolIndex;
+    dispose(): Promise<void>;
+}

package/dist/modules/core/symbols.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Regex-based Symbol Extraction
+ *
+ * Extracts symbols from code using regular expressions.
+ * Language-agnostic but optimized for common patterns.
+ */
+export type SymbolType = "function" | "class" | "variable" | "interface" | "type" | "enum" | "method" | "other";
+export interface ExtractedSymbol {
+    name: string;
+    type: SymbolType;
+    line: number;
+    isExported: boolean;
+}
+/**
+ * Extract symbols from code content using regex patterns.
+ *
+ * @param content - The source code content
+ * @returns Array of extracted symbols with their locations
+ */
+export declare function extractSymbols(content: string): ExtractedSymbol[];
+/**
+ * Extract symbol names as keywords for BM25 indexing.
+ *
+ * @param symbols - Array of extracted symbols
+ * @returns Array of unique symbol names
+ */
+export declare function symbolsToKeywords(symbols: ExtractedSymbol[]): string[];

package/dist/modules/core/symbols.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for regex-based symbol extraction
+ */
+export {};

package/dist/modules/{semantic → language/typescript}/index.d.ts

@@ -1,15 +1,14 @@
 /**
- * Semantic Index Module
+ * TypeScript Language Index Module
  *
- * Uses local text embeddings for natural language code search.
- * Implements a tiered index system:
- * - Tier 1: Lightweight file summaries with keywords for fast filtering
- * - Tier 2: Full chunk embeddings for semantic similarity
+ * Provides TypeScript/JavaScript-aware code search using:
+ * - AST parsing via TypeScript Compiler API
+ * - Local text embeddings for semantic similarity
+ * - BM25 keyword matching for fast filtering
  *
- * This approach keeps the filesystem-based design while enabling
- * efficient search by only loading relevant files.
+ * Index location: .raggrep/index/language/typescript/
  */
-import { IndexModule, IndexContext, SearchContext, SearchOptions, FileIndex, SearchResult, ModuleConfig } from '../../types';
+import { IndexModule, IndexContext, SearchContext, SearchOptions, FileIndex, SearchResult, ModuleConfig } from '../../../types';
 /** Default minimum similarity score for search results */
 export declare const DEFAULT_MIN_SCORE = 0.15;
 /** Default number of results to return */
@@ -23,10 +22,10 @@ export interface SemanticModuleData {
     embeddingModel: string;
     [key: string]: unknown;
 }
-export declare class SemanticModule implements IndexModule {
-    readonly id = "semantic";
-    readonly name = "Semantic Search";
-    readonly description = "Natural language code search using local text embeddings";
+export declare class TypeScriptModule implements IndexModule {
+    readonly id = "language/typescript";
+    readonly name = "TypeScript Search";
+    readonly description = "TypeScript-aware code search with AST parsing and semantic embeddings";
     readonly version = "1.0.0";
     private embeddingConfig;
     private symbolicIndex;

package/dist/types.d.ts

@@ -4,12 +4,13 @@
  * This file re-exports domain entities and defines module interfaces.
  * For new code, prefer importing directly from 'domain/entities'.
  */
-export type { Chunk, ChunkType, FileIndex, FileManifestEntry, ModuleManifest, GlobalManifest, FileSummary, Tier1Manifest, SearchResult, SearchOptions, Config, ModuleConfig, } from './domain/entities';
+export type { Chunk, ChunkType, FileIndex, FileManifestEntry, ModuleManifest, GlobalManifest, FileSummary, Tier1Manifest, SearchResult, SearchOptions, SearchContributions, CoreContribution, LanguageContribution, IntrospectionContribution, Config, ModuleConfig, } from './domain/entities';
 export { createChunkId, DEFAULT_SEARCH_OPTIONS, DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS, createDefaultConfig, } from './domain/entities';
 import type { Config, FileIndex, SearchResult, SearchOptions, ModuleConfig } from './domain/entities';
 /**
  * Context provided to modules during indexing
  */
+import type { FileIntrospection } from './introspection';
 export interface IndexContext {
     rootDir: string;
     config: Config;
@@ -19,6 +20,8 @@ export interface IndexContext {
     getFileStats: (filepath: string) => Promise<{
         lastModified: string;
     }>;
+    /** Get introspection data for a file (if available) */
+    getIntrospection?: (filepath: string) => FileIntrospection | undefined;
 }
 /**
  * Context provided to modules during search

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raggrep",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,7 +12,7 @@
     }
   },
   "bin": {
-    "raggrep": "./dist/cli/main.js"
+    "raggrep": "dist/cli/main.js"
   },
   "files": [
     "dist",
@@ -22,13 +22,13 @@
   "scripts": {
     "build": "bun run build:clean && bun run build:bundle && bun run build:types && bun run build:shebang",
     "build:clean": "rm -rf dist",
-    "build:bundle": "bun build src/index.ts --outdir dist --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar' && bun build src/cli/main.ts --outdir dist/cli --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar'",
+    "build:bundle": "bun build src/index.ts --outdir dist --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar' && bun build src/app/cli/main.ts --outdir dist/cli --target node --sourcemap=external --external '@xenova/transformers' --external 'glob' --external 'typescript' --external 'chokidar'",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
     "build:shebang": "echo '#!/usr/bin/env node' | cat - dist/cli/main.js > temp && mv temp dist/cli/main.js && chmod +x dist/cli/main.js",
     "prepublishOnly": "bun run build",
-    "raggrep": "bun run src/cli/main.ts",
+    "raggrep": "bun run src/app/cli/main.ts",
     "test": "bun test",
-    "dev": "bun run src/cli/main.ts"
+    "dev": "bun run src/app/cli/main.ts"
   },
   "keywords": [
     "rag",

package/dist/application/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Application Layer
- *
- * Contains use cases that orchestrate the application's business logic.
- * Use cases depend on domain entities and infrastructure ports (not concrete implementations).
- */
-export * from './usecases';

package/dist/utils/bm25.d.ts

@@ -1,9 +0,0 @@
-/**
- * BM25 Search Utilities
- *
- * Re-exports BM25 functionality from the domain layer.
- * This file exists for backwards compatibility with existing code.
- *
- * For new code, import directly from 'domain/services'.
- */
-export { BM25Index, tokenize, normalizeScore, type BM25Document, type BM25Result, } from '../domain/services/bm25';

package/dist/utils/embeddings.d.ts

@@ -1,46 +0,0 @@
-export declare const EMBEDDING_MODELS: {
-    readonly 'all-MiniLM-L6-v2': "Xenova/all-MiniLM-L6-v2";
-    readonly 'all-MiniLM-L12-v2': "Xenova/all-MiniLM-L12-v2";
-    readonly 'bge-small-en-v1.5': "Xenova/bge-small-en-v1.5";
-    readonly 'paraphrase-MiniLM-L3-v2': "Xenova/paraphrase-MiniLM-L3-v2";
-};
-export type EmbeddingModelName = keyof typeof EMBEDDING_MODELS;
-export interface EmbeddingConfig {
-    model: EmbeddingModelName;
-    /** Show progress during model download */
-    showProgress?: boolean;
-}
-/**
- * Configure the embedding model
- */
-export declare function configureEmbeddings(config: Partial<EmbeddingConfig>): void;
-/**
- * Get embedding for a single text
- */
-export declare function getEmbedding(text: string): Promise<number[]>;
-/**
- * Get embeddings for multiple texts (batched for efficiency)
- *
- * Processes texts in batches of BATCH_SIZE for better performance
- * while avoiding memory issues with very large batches.
- *
- * @param texts - Array of texts to embed
- * @returns Array of embedding vectors
- */
-export declare function getEmbeddings(texts: string[]): Promise<number[][]>;
-/**
- * Calculate cosine similarity between two vectors
- */
-export declare function cosineSimilarity(a: number[], b: number[]): number;
-/**
- * Get current embedding configuration
- */
-export declare function getEmbeddingConfig(): EmbeddingConfig;
-/**
- * Get the cache directory path
- */
-export declare function getCacheDir(): string;
-/**
- * Check if a model is already cached
- */
-export declare function isModelCached(model?: EmbeddingModelName): Promise<boolean>;