raggrep 0.1.5 → 0.1.6

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

@@ -11,9 +11,27 @@ 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
+ * Get the index storage directory path.
+ *
+ * Index data is stored in a system temp directory to avoid cluttering
+ * the user's project with index files. The temp path is derived from
+ * a hash of the project's absolute path to ensure uniqueness.
+ *
+ * Structure: {tmpdir}/raggrep-indexes/{hash}/
+ *
+ * @param rootDir - Absolute path to the project root
+ * @returns Absolute path to the index storage directory
+ */
+export declare function getRaggrepDir(rootDir: string, _config?: Config): string;
+/**
+ * Get the index storage path and also return useful metadata.
+ * Helpful for debugging and user feedback.
  */
-export declare function getRaggrepDir(rootDir: string, config?: Config): string;
+export declare function getIndexLocation(rootDir: string): {
+    indexDir: string;
+    projectRoot: string;
+    projectHash: string;
+};
 /**
  * Get the index data directory for a specific module
  */
@@ -27,7 +45,8 @@ export declare function getModuleManifestPath(rootDir: string, moduleId: string,
  */
 export declare function getGlobalManifestPath(rootDir: string, config?: Config): string;
 /**
- * Get the config file path
+ * Get the config file path.
+ * Note: Config is still stored in the temp index directory, not the project.
  */
 export declare function getConfigPath(rootDir: string, config?: Config): string;
 /**

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

@@ -3,4 +3,4 @@
  *
  * 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";
+export { DEFAULT_CONFIG, EMBEDDING_MODELS, getRaggrepDir, getIndexLocation, getModuleIndexPath, getModuleManifestPath, getGlobalManifestPath, getConfigPath, loadConfig, saveConfig, getModuleConfig, getEmbeddingConfigFromModule, } from "./configLoader";

package/dist/introspection/conventions/configFiles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Configuration File Conventions
+ *
+ * Patterns for recognizing common configuration files.
+ */
+import type { FileConvention } from "./types";
+/**
+ * Configuration file conventions.
+ */
+export declare const configFileConventions: FileConvention[];

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

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

package/dist/introspection/conventions/entryPoints.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Entry Point Conventions
+ *
+ * Patterns for recognizing module entry points and barrel files.
+ */
+import type { FileConvention } from "./types";
+/**
+ * Entry point conventions for JavaScript/TypeScript projects.
+ */
+export declare const entryPointConventions: FileConvention[];

package/dist/introspection/conventions/frameworks/convex.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convex Framework Conventions
+ *
+ * Patterns for recognizing Convex backend files and structures.
+ * Convex is a backend platform with real-time sync.
+ */
+import type { FrameworkConventions } from "../types";
+/**
+ * Convex framework conventions provider.
+ */
+export declare const convexFramework: FrameworkConventions;

package/dist/introspection/conventions/frameworks/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Framework Conventions Registry
+ *
+ * Central registry for framework-specific conventions.
+ * Add new frameworks here to extend convention support.
+ */
+import type { FrameworkConventions } from "../types";
+/**
+ * All registered framework convention providers.
+ * Add new frameworks to this array.
+ */
+export declare const frameworkProviders: FrameworkConventions[];
+/**
+ * Get all framework conventions.
+ */
+export declare function getAllFrameworkConventions(): import("..").FileConvention[];
+/**
+ * Get frameworks by ID.
+ */
+export declare function getFramework(id: string): FrameworkConventions | undefined;
+export { nextjsFramework } from "./nextjs";
+export { convexFramework } from "./convex";

package/dist/introspection/conventions/frameworks/nextjs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Next.js Framework Conventions
+ *
+ * Patterns for recognizing Next.js specific files and structures.
+ */
+import type { FrameworkConventions } from "../types";
+/**
+ * Next.js framework conventions provider.
+ */
+export declare const nextjsFramework: FrameworkConventions;

package/dist/introspection/conventions/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * File Conventions Module
+ *
+ * Provides semantic keywords for files based on common conventions.
+ * This helps improve search relevance by recognizing special file patterns.
+ *
+ * Categories:
+ * - Entry Points: index.ts, main.ts, App.tsx, etc.
+ * - Configuration: tsconfig.json, .prettierrc, package.json, etc.
+ * - Frameworks: Next.js, Convex, and other framework-specific patterns
+ * - Type Definitions: *.d.ts, *.types.ts
+ *
+ * Extensibility:
+ * - Add new conventions to entryPoints.ts or configFiles.ts
+ * - Add new frameworks in the frameworks/ directory
+ */
+import type { FileConvention, ConventionMatch } from "./types";
+export type { FileConvention, ConventionCategory, ConventionMatch, FrameworkConventions, } from "./types";
+/**
+ * Get all conventions including built-in ones.
+ */
+export declare function getConventions(): FileConvention[];
+/**
+ * Match a filepath against all conventions and return keywords.
+ *
+ * @param filepath - The file path (relative to project root)
+ * @returns Array of keywords from all matching conventions
+ */
+export declare function getConventionKeywords(filepath: string): string[];
+/**
+ * Match a filepath against all conventions and return detailed matches.
+ *
+ * @param filepath - The file path (relative to project root)
+ * @returns Array of convention matches with details
+ */
+export declare function matchConventions(filepath: string): ConventionMatch[];
+export { entryPointConventions } from "./entryPoints";
+export { configFileConventions } from "./configFiles";
+export { frameworkProviders, getAllFrameworkConventions } from "./frameworks";

package/dist/introspection/conventions/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Types for File Conventions
+ *
+ * Defines patterns for recognizing special files and their semantic meaning.
+ */
+/**
+ * A file convention pattern that matches files and provides keywords.
+ */
+export interface FileConvention {
+    /** Unique identifier for this convention */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of what this convention represents */
+    description: string;
+    /** Category for grouping conventions */
+    category: ConventionCategory;
+    /**
+     * Match function - returns true if the filepath matches this convention.
+     * @param filepath - The file path (relative to project root)
+     * @param filename - Just the filename
+     * @param extension - File extension including dot (e.g., ".ts")
+     */
+    match: (filepath: string, filename: string, extension: string) => boolean;
+    /**
+     * Keywords to add when this convention matches.
+     * These will be added to the search index.
+     */
+    keywords: string[];
+    /**
+     * Optional: Additional keywords based on the filepath.
+     * Useful for extracting context from the path.
+     */
+    dynamicKeywords?: (filepath: string) => string[];
+}
+/**
+ * Categories for organizing conventions.
+ */
+export type ConventionCategory = "entry-point" | "configuration" | "framework" | "types" | "test" | "documentation" | "build" | "deployment";
+/**
+ * A framework convention provider.
+ * Frameworks can register their own conventions.
+ */
+export interface FrameworkConventions {
+    /** Framework identifier */
+    id: string;
+    /** Framework name */
+    name: string;
+    /** Check if this framework is detected in the project */
+    detect: (filepath: string, allFiles?: string[]) => boolean;
+    /** Conventions specific to this framework */
+    conventions: FileConvention[];
+}
+/**
+ * Result of matching conventions against a file.
+ */
+export interface ConventionMatch {
+    /** The convention that matched */
+    convention: FileConvention;
+    /** Keywords from this match */
+    keywords: string[];
+}

package/dist/tests/integration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration Tests for RAGgrep
+ *
+ * These tests run against the .simulation folder and validate
+ * end-to-end functionality of indexing and search.
+ *
+ * Tests are run sequentially to ensure proper state management.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raggrep",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   "type": "module",
   "main": "./dist/index.js",