cursor-recursive-rag 0.2.0-alpha.2 → 0.2.0

package/dist/config/rulesConfig.d.ts

@@ -0,0 +1,486 @@
+/**
+ * Rules Analyzer Configuration
+ *
+ * User-configurable settings for the rules optimizer.
+ * Can be set via:
+ * - Config file: ~/.cursor-rag/rules-config.json
+ * - Dashboard UI
+ * - CLI flags
+ */
+import { z } from 'zod';
+/**
+ * Custom version check pattern
+ */
+export declare const VersionCheckSchema: z.ZodObject<{
+    /** Technology name (e.g., "Laravel", "React") */
+    name: z.ZodString;
+    /** Regex pattern to match version mentions (should have one capture group for version) */
+    pattern: z.ZodString;
+    /** Current/expected version number */
+    currentVersion: z.ZodString;
+    /** Whether this check is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    name: string;
+    enabled: boolean;
+    currentVersion: string;
+}, {
+    pattern: string;
+    name: string;
+    currentVersion: string;
+    enabled?: boolean | undefined;
+}>;
+export type VersionCheck = z.infer<typeof VersionCheckSchema>;
+/**
+ * Custom deprecation pattern
+ */
+export declare const DeprecationPatternSchema: z.ZodObject<{
+    /** Pattern name/identifier */
+    name: z.ZodString;
+    /** Regex pattern to detect the deprecated usage */
+    pattern: z.ZodString;
+    /** Human-readable reason why this is deprecated */
+    reason: z.ZodString;
+    /** Suggested alternative */
+    suggestion: z.ZodOptional<z.ZodString>;
+    /** Whether this check is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    name: string;
+    enabled: boolean;
+    reason: string;
+    suggestion?: string | undefined;
+}, {
+    pattern: string;
+    name: string;
+    reason: string;
+    enabled?: boolean | undefined;
+    suggestion?: string | undefined;
+}>;
+export type DeprecationPattern = z.infer<typeof DeprecationPatternSchema>;
+/**
+ * Custom tag extraction pattern
+ */
+export declare const TagPatternSchema: z.ZodObject<{
+    /** Tag that will be applied */
+    tag: z.ZodString;
+    /** Regex pattern to match content */
+    pattern: z.ZodString;
+    /** Whether this pattern is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    enabled: boolean;
+    tag: string;
+}, {
+    pattern: string;
+    tag: string;
+    enabled?: boolean | undefined;
+}>;
+export type TagPattern = z.infer<typeof TagPatternSchema>;
+/**
+ * LLM Provider type
+ */
+export declare const LLMProviderTypeSchema: z.ZodEnum<["openai", "anthropic", "deepseek", "groq", "ollama", "openrouter"]>;
+export type LLMProviderType = z.infer<typeof LLMProviderTypeSchema>;
+/**
+ * LLM configuration for rules analyzer
+ */
+export declare const LLMConfigSchema: z.ZodDefault<z.ZodObject<{
+    /** Selected provider */
+    provider: z.ZodOptional<z.ZodEnum<["openai", "anthropic", "deepseek", "groq", "ollama", "openrouter"]>>;
+    /** API key (stored securely) */
+    apiKey: z.ZodOptional<z.ZodString>;
+    /** Selected model */
+    model: z.ZodOptional<z.ZodString>;
+    /** Base URL override (for Ollama or custom endpoints) */
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model?: string | undefined;
+    provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}, {
+    model?: string | undefined;
+    provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+    apiKey?: string | undefined;
+    baseUrl?: string | undefined;
+}>>;
+export type LLMConfig = z.infer<typeof LLMConfigSchema>;
+/**
+ * Natural language rule (interpreted by LLM)
+ */
+export declare const NaturalRuleSchema: z.ZodObject<{
+    /** The rule description in plain English */
+    rule: z.ZodString;
+    /** Severity level */
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    /** Whether this rule is enabled */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    rule: string;
+    severity: "error" | "info" | "warning";
+}, {
+    rule: string;
+    enabled?: boolean | undefined;
+    severity?: "error" | "info" | "warning" | undefined;
+}>;
+export type NaturalRule = z.infer<typeof NaturalRuleSchema>;
+/**
+ * Full rules analyzer configuration
+ */
+export declare const RulesAnalyzerConfigSchema: z.ZodObject<{
+    /** Analysis settings */
+    analysis: z.ZodDefault<z.ZodObject<{
+        /** Minimum similarity threshold for duplicate detection (0-1) */
+        duplicateThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Maximum age in days before flagging as potentially outdated */
+        maxAgeDays: z.ZodDefault<z.ZodNumber>;
+        /** Years back to consider as "old" when referenced */
+        oldYearThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Whether to detect conflicts */
+        detectConflicts: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to detect outdated rules */
+        detectOutdated: z.ZodDefault<z.ZodBoolean>;
+        /** Whether to use LLM for enhanced analysis */
+        useLLM: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        duplicateThreshold: number;
+        detectOutdated: boolean;
+        detectConflicts: boolean;
+        useLLM: boolean;
+        maxAgeDays: number;
+        oldYearThreshold: number;
+    }, {
+        duplicateThreshold?: number | undefined;
+        detectOutdated?: boolean | undefined;
+        detectConflicts?: boolean | undefined;
+        useLLM?: boolean | undefined;
+        maxAgeDays?: number | undefined;
+        oldYearThreshold?: number | undefined;
+    }>>;
+    /** LLM provider configuration */
+    llm: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+        /** Selected provider */
+        provider: z.ZodOptional<z.ZodEnum<["openai", "anthropic", "deepseek", "groq", "ollama", "openrouter"]>>;
+        /** API key (stored securely) */
+        apiKey: z.ZodOptional<z.ZodString>;
+        /** Selected model */
+        model: z.ZodOptional<z.ZodString>;
+        /** Base URL override (for Ollama or custom endpoints) */
+        baseUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model?: string | undefined;
+        provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+        apiKey?: string | undefined;
+        baseUrl?: string | undefined;
+    }, {
+        model?: string | undefined;
+        provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+        apiKey?: string | undefined;
+        baseUrl?: string | undefined;
+    }>>>;
+    /** Natural language rules (LLM-interpreted) */
+    naturalRules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** The rule description in plain English */
+        rule: z.ZodString;
+        /** Severity level */
+        severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+        /** Whether this rule is enabled */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        rule: string;
+        severity: "error" | "info" | "warning";
+    }, {
+        rule: string;
+        enabled?: boolean | undefined;
+        severity?: "error" | "info" | "warning" | undefined;
+    }>, "many">>;
+    /** Custom version checks */
+    versionChecks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Technology name (e.g., "Laravel", "React") */
+        name: z.ZodString;
+        /** Regex pattern to match version mentions (should have one capture group for version) */
+        pattern: z.ZodString;
+        /** Current/expected version number */
+        currentVersion: z.ZodString;
+        /** Whether this check is enabled */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        name: string;
+        enabled: boolean;
+        currentVersion: string;
+    }, {
+        pattern: string;
+        name: string;
+        currentVersion: string;
+        enabled?: boolean | undefined;
+    }>, "many">>;
+    /** Custom deprecation patterns */
+    deprecationPatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Pattern name/identifier */
+        name: z.ZodString;
+        /** Regex pattern to detect the deprecated usage */
+        pattern: z.ZodString;
+        /** Human-readable reason why this is deprecated */
+        reason: z.ZodString;
+        /** Suggested alternative */
+        suggestion: z.ZodOptional<z.ZodString>;
+        /** Whether this check is enabled */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        name: string;
+        enabled: boolean;
+        reason: string;
+        suggestion?: string | undefined;
+    }, {
+        pattern: string;
+        name: string;
+        reason: string;
+        enabled?: boolean | undefined;
+        suggestion?: string | undefined;
+    }>, "many">>;
+    /** Custom tag extraction patterns */
+    tagPatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Tag that will be applied */
+        tag: z.ZodString;
+        /** Regex pattern to match content */
+        pattern: z.ZodString;
+        /** Whether this pattern is enabled */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        enabled: boolean;
+        tag: string;
+    }, {
+        pattern: string;
+        tag: string;
+        enabled?: boolean | undefined;
+    }>, "many">>;
+    /** File patterns */
+    files: z.ZodDefault<z.ZodObject<{
+        /** Patterns to include */
+        include: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Patterns to exclude */
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        include: string[];
+        exclude: string[];
+    }, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>>;
+    /** Optimization settings */
+    optimization: z.ZodDefault<z.ZodObject<{
+        /** Aggressiveness level */
+        aggressiveness: z.ZodDefault<z.ZodEnum<["conservative", "balanced", "aggressive"]>>;
+        /** Maximum tokens per merged rule */
+        maxTokensPerRule: z.ZodDefault<z.ZodNumber>;
+        /** Create backups before modifications */
+        createBackups: z.ZodDefault<z.ZodBoolean>;
+        /** Backup directory */
+        backupDir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        aggressiveness: "conservative" | "balanced" | "aggressive";
+        createBackups: boolean;
+        backupDir: string;
+        maxTokensPerRule: number;
+    }, {
+        aggressiveness?: "conservative" | "balanced" | "aggressive" | undefined;
+        createBackups?: boolean | undefined;
+        backupDir?: string | undefined;
+        maxTokensPerRule?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    optimization: {
+        aggressiveness: "conservative" | "balanced" | "aggressive";
+        createBackups: boolean;
+        backupDir: string;
+        maxTokensPerRule: number;
+    };
+    analysis: {
+        duplicateThreshold: number;
+        detectOutdated: boolean;
+        detectConflicts: boolean;
+        useLLM: boolean;
+        maxAgeDays: number;
+        oldYearThreshold: number;
+    };
+    llm: {
+        model?: string | undefined;
+        provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+        apiKey?: string | undefined;
+        baseUrl?: string | undefined;
+    };
+    naturalRules: {
+        enabled: boolean;
+        rule: string;
+        severity: "error" | "info" | "warning";
+    }[];
+    versionChecks: {
+        pattern: string;
+        name: string;
+        enabled: boolean;
+        currentVersion: string;
+    }[];
+    deprecationPatterns: {
+        pattern: string;
+        name: string;
+        enabled: boolean;
+        reason: string;
+        suggestion?: string | undefined;
+    }[];
+    tagPatterns: {
+        pattern: string;
+        enabled: boolean;
+        tag: string;
+    }[];
+    files: {
+        include: string[];
+        exclude: string[];
+    };
+}, {
+    optimization?: {
+        aggressiveness?: "conservative" | "balanced" | "aggressive" | undefined;
+        createBackups?: boolean | undefined;
+        backupDir?: string | undefined;
+        maxTokensPerRule?: number | undefined;
+    } | undefined;
+    analysis?: {
+        duplicateThreshold?: number | undefined;
+        detectOutdated?: boolean | undefined;
+        detectConflicts?: boolean | undefined;
+        useLLM?: boolean | undefined;
+        maxAgeDays?: number | undefined;
+        oldYearThreshold?: number | undefined;
+    } | undefined;
+    llm?: {
+        model?: string | undefined;
+        provider?: "openai" | "anthropic" | "deepseek" | "groq" | "ollama" | "openrouter" | undefined;
+        apiKey?: string | undefined;
+        baseUrl?: string | undefined;
+    } | undefined;
+    naturalRules?: {
+        rule: string;
+        enabled?: boolean | undefined;
+        severity?: "error" | "info" | "warning" | undefined;
+    }[] | undefined;
+    versionChecks?: {
+        pattern: string;
+        name: string;
+        currentVersion: string;
+        enabled?: boolean | undefined;
+    }[] | undefined;
+    deprecationPatterns?: {
+        pattern: string;
+        name: string;
+        reason: string;
+        enabled?: boolean | undefined;
+        suggestion?: string | undefined;
+    }[] | undefined;
+    tagPatterns?: {
+        pattern: string;
+        tag: string;
+        enabled?: boolean | undefined;
+    }[] | undefined;
+    files?: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+}>;
+export type RulesAnalyzerConfig = z.infer<typeof RulesAnalyzerConfigSchema>;
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_RULES_CONFIG: RulesAnalyzerConfig;
+/**
+ * Available LLM providers with their requirements
+ */
+export declare const LLM_PROVIDERS: readonly [{
+    readonly id: "openai";
+    readonly name: "OpenAI";
+    readonly requiresKey: true;
+    readonly placeholder: "sk-...";
+}, {
+    readonly id: "anthropic";
+    readonly name: "Anthropic";
+    readonly requiresKey: true;
+    readonly placeholder: "sk-ant-...";
+}, {
+    readonly id: "deepseek";
+    readonly name: "DeepSeek";
+    readonly requiresKey: true;
+    readonly placeholder: "sk-...";
+}, {
+    readonly id: "groq";
+    readonly name: "Groq";
+    readonly requiresKey: true;
+    readonly placeholder: "gsk_...";
+}, {
+    readonly id: "ollama";
+    readonly name: "Ollama (Local)";
+    readonly requiresKey: false;
+    readonly placeholder: "";
+}, {
+    readonly id: "openrouter";
+    readonly name: "OpenRouter";
+    readonly requiresKey: true;
+    readonly placeholder: "sk-or-...";
+}];
+/**
+ * Example configuration with common patterns (shown in dashboard as templates)
+ */
+export declare const EXAMPLE_PATTERNS: {
+    versionChecks: {
+        name: string;
+        pattern: string;
+        currentVersion: string;
+        enabled: boolean;
+    }[];
+    deprecationPatterns: {
+        name: string;
+        pattern: string;
+        reason: string;
+        suggestion: string;
+        enabled: boolean;
+    }[];
+    tagPatterns: {
+        tag: string;
+        pattern: string;
+        enabled: boolean;
+    }[];
+};
+/**
+ * Load rules analyzer configuration
+ */
+export declare function loadRulesConfig(): RulesAnalyzerConfig;
+/**
+ * Save rules analyzer configuration
+ */
+export declare function saveRulesConfig(config: RulesAnalyzerConfig): void;
+/**
+ * Merge user config with defaults
+ */
+export declare function mergeRulesConfig(userConfig: Partial<RulesAnalyzerConfig>): RulesAnalyzerConfig;
+/**
+ * Validate a single pattern (for UI validation)
+ */
+export declare function validatePattern(pattern: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Test a pattern against sample content
+ */
+export declare function testPattern(pattern: string, content: string): {
+    matches: boolean;
+    matchedText?: string;
+    captureGroups?: string[];
+};
+//# sourceMappingURL=rulesConfig.d.ts.map

package/dist/config/rulesConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulesConfig.d.ts","sourceRoot":"","sources":["../../src/config/rulesConfig.ts"],"names":[],"mappings":"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"}