raggrep 0.1.5 → 0.1.7

package/dist/domain/entities/conventions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Convention Types
+ *
+ * Defines patterns for recognizing special files and their semantic meaning.
+ * Used by the conventions service to add semantic keywords to the search index.
+ */
+/**
+ * Categories for organizing conventions.
+ */
+export type ConventionCategory = "entry-point" | "configuration" | "framework" | "types" | "test" | "documentation" | "build" | "deployment";
+/**
+ * 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[];
+}
+/**
+ * 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/domain/entities/index.d.ts

@@ -12,3 +12,5 @@ export type { SearchResult, SearchOptions, SearchContributions, CoreContribution
 export { DEFAULT_SEARCH_OPTIONS } from "./searchResult";
 export type { Config, ModuleConfig } from "./config";
 export { DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS, createDefaultConfig, } from "./config";
+export type { FileIntrospection, ProjectStructure, Project, ProjectType, Scope, IntrospectionConfig, } from "./introspection";
+export type { FileConvention, ConventionCategory, FrameworkConventions, ConventionMatch, } from "./conventions";

package/dist/domain/services/conventions/configFiles.d.ts

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

package/dist/domain/services/conventions/conventions.test.d.ts

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

package/dist/domain/services/conventions/entryPoints.d.ts

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

package/dist/domain/services/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 "../../../entities/conventions";
+/**
+ * Convex framework conventions provider.
+ */
+export declare const convexFramework: FrameworkConventions;

package/dist/domain/services/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 "../../../entities/conventions";
+/**
+ * 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/domain/services/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 "../../../entities/conventions";
+/**
+ * Next.js framework conventions provider.
+ */
+export declare const nextjsFramework: FrameworkConventions;

package/dist/domain/services/conventions/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * File Conventions Service
+ *
+ * Pure functions for matching files against conventions and extracting keywords.
+ * No I/O operations - all functions operate on file paths.
+ *
+ * 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 "../../entities/conventions";
+export type { FileConvention, ConventionCategory, ConventionMatch, FrameworkConventions, } from "../../entities/conventions";
+/**
+ * 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/domain/services/introspection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Introspection Service
+ *
+ * Pure functions for extracting file metadata from paths and content.
+ * No I/O operations - all functions operate on provided data.
+ */
+import type { FileIntrospection, Project, ProjectStructure, Scope } from "../entities/introspection";
+/**
+ * Extract introspection metadata for a file.
+ *
+ * @param filepath - Relative file path
+ * @param structure - Project structure (from detectProjectStructure)
+ * @param fileContent - Optional file content for framework detection
+ */
+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[];
+/**
+ * Detect scope from project name.
+ */
+export declare function detectScopeFromName(name: string): Scope;
+/**
+ * Find which project a file belongs to.
+ */
+export declare function findProjectForFile(filepath: string, structure: ProjectStructure): Project;
+/**
+ * Calculate search boost based on introspection and query.
+ */
+export declare function calculateIntrospectionBoost(intro: FileIntrospection, query: string): number;