qraft/dist/utils/qraftPatterns.d.ts

A powerful CLI tool to qraft structured project setups from GitHub template repositories

import { ConfigManager } from './config';
/**
 * Categories of qraft-specific patterns
 */
export declare enum QraftPatternCategory {
    LOCAL = "local",
    GLOBAL = "global",
    CACHE = "cache",
    CONFIG = "config"
}
/**
 * A qraft-specific gitignore pattern with metadata
 */
export interface QraftPattern {
    pattern: string;
    category: QraftPatternCategory;
    description: string;
    isStatic: boolean;
}
/**
 * Collection of qraft patterns organized by category
 */
export interface QraftPatternCollection {
    local: QraftPattern[];
    global: QraftPattern[];
    cache: QraftPattern[];
    config: QraftPattern[];
}
/**
 * QraftPatterns utility manages all qraft-specific gitignore patterns
 */
export declare class QraftPatterns {
    private configManager;
    constructor(configManager?: ConfigManager);
    /**
     * Get all static qraft patterns that don't depend on configuration
     * @returns QraftPattern[] Array of static patterns
     */
    getStaticPatterns(): QraftPattern[];
    /**
     * Get dynamic qraft patterns that depend on configuration
     * @returns Promise<QraftPattern[]> Array of dynamic patterns
     */
    getDynamicPatterns(): Promise<QraftPattern[]>;
    /**
     * Get cache-related patterns from configuration
     * @param config Qraft configuration
     * @returns Promise<QraftPattern[]> Cache patterns
     */
    private getCachePatterns;
    /**
     * Get registry-related patterns from configuration
     * @param config Qraft configuration
     * @returns Promise<QraftPattern[]> Registry patterns
     */
    private getRegistryPatterns;
    /**
     * Get authentication-related patterns from configuration
     * @param _config Qraft configuration
     * @returns Promise<QraftPattern[]> Authentication patterns
     */
    private getAuthPatterns;
    /**
     * Get configuration-specific patterns based on current config
     * @returns Promise<QraftPattern[]> Configuration-specific patterns
     */
    getConfigSpecificPatterns(): Promise<QraftPattern[]>;
    /**
     * Sanitize registry name for use in file patterns
     * @param registryName Registry name to sanitize
     * @returns string Sanitized name
     */
    private sanitizeRegistryName;
    /**
     * Get patterns based on current working directory and config
     * @param targetDirectory Target directory for .gitignore
     * @returns Promise<QraftPattern[]> Context-aware patterns
     */
    getContextAwarePatterns(targetDirectory: string): Promise<QraftPattern[]>;
    /**
     * Check if a pattern is relevant for the current context
     * @param pattern Pattern to check
     * @param targetDirectory Target directory
     * @returns Promise<boolean> True if pattern is relevant
     */
    private isPatternRelevantForContext;
    /**
     * Get all qraft patterns (static + dynamic)
     * @returns Promise<QraftPattern[]> Array of all patterns
     */
    getAllPatterns(): Promise<QraftPattern[]>;
    /**
     * Get patterns organized by category
     * @returns Promise<QraftPatternCollection> Patterns organized by category
     */
    getPatternsByCategory(): Promise<QraftPatternCollection>;
    /**
     * Get just the pattern strings (for use with GitignoreManager)
     * @returns Promise<string[]> Array of pattern strings
     */
    getPatternStrings(): Promise<string[]>;
    /**
     * Get patterns for a specific category
     * @param category Category to filter by
     * @returns Promise<QraftPattern[]> Patterns in the specified category
     */
    getPatternsForCategory(category: QraftPatternCategory): Promise<QraftPattern[]>;
    /**
     * Check if a directory is a system cache directory that shouldn't be ignored
     * @param directory Directory path to check
     * @returns boolean True if it's a system cache directory
     */
    private isSystemCacheDirectory;
    /**
     * Convert an absolute path to a relative pattern suitable for .gitignore
     * @param absolutePath Absolute path to convert
     * @returns string Relative pattern
     */
    private getRelativePattern;
    /**
     * Get the default section title for qraft patterns
     * @returns string Section title
     */
    getSectionTitle(): string;
    /**
     * Get the default section description for qraft patterns
     * @returns string Section description
     */
    getSectionDescription(): string;
    /**
     * Get patterns formatted for display (with descriptions)
     * @returns Promise<string[]> Array of formatted pattern descriptions
     */
    getFormattedPatterns(): Promise<string[]>;
    /**
     * Categorize patterns into local and global scopes
     * @returns Promise<{local: QraftPattern[], global: QraftPattern[]}> Patterns categorized by scope
     */
    categorizeByScope(): Promise<{
        local: QraftPattern[];
        global: QraftPattern[];
    }>;
    /**
     * Get only local-scope patterns (patterns that affect the current project)
     * @returns Promise<QraftPattern[]> Local-scope patterns
     */
    getLocalPatterns(): Promise<QraftPattern[]>;
    /**
     * Get only global-scope patterns (patterns that affect user's system)
     * @returns Promise<QraftPattern[]> Global-scope patterns
     */
    getGlobalPatterns(): Promise<QraftPattern[]>;
    /**
     * Determine if a pattern is local-scope (affects current project only)
     * @param pattern Pattern to check
     * @returns boolean True if pattern is local-scope
     */
    private isLocalScopePattern;
    /**
     * Check if a pattern is relative to the current project
     * @param pattern Pattern to check
     * @returns boolean True if pattern is project-relative
     */
    private isProjectRelativePattern;
    /**
     * Get patterns suitable for project-level .gitignore
     * @returns Promise<string[]> Array of project-level pattern strings
     */
    getProjectPatterns(): Promise<string[]>;
    /**
     * Get patterns that should be in global .gitignore
     * @returns Promise<string[]> Array of global pattern strings
     */
    getGlobalGitignorePatterns(): Promise<string[]>;
    /**
     * Filter patterns based on current working directory context
     * @param targetDirectory Directory where .gitignore will be created
     * @returns Promise<QraftPattern[]> Patterns relevant to the target directory
     */
    getRelevantPatterns(targetDirectory: string): Promise<QraftPattern[]>;
    /**
     * Check if a pattern is relevant for a specific directory
     * @param pattern Pattern to check
     * @param targetDirectory Target directory path
     * @returns boolean True if pattern is relevant
     */
    private isPatternRelevantForDirectory;
    /**
     * Check if a cache pattern is relevant for a directory
     * @param pattern Cache pattern
     * @param targetDirectory Target directory
     * @returns boolean True if relevant
     */
    private isCachePatternRelevant;
    /**
     * Check if a config pattern is relevant for a directory
     * @param pattern Config pattern
     * @param _targetDirectory Target directory
     * @returns boolean True if relevant
     */
    private isConfigPatternRelevant;
    /**
     * Validate a qraft pattern for correctness and safety
     * @param pattern Pattern to validate
     * @returns {isValid: boolean, errors: string[]} Validation result
     */
    validatePattern(pattern: string): {
        isValid: boolean;
        errors: string[];
    };
    /**
     * Normalize a pattern to ensure consistency
     * @param pattern Pattern to normalize
     * @returns string Normalized pattern
     */
    normalizePattern(pattern: string): string;
    /**
     * Validate and normalize a collection of patterns
     * @param patterns Array of patterns to process
     * @returns {valid: string[], invalid: {pattern: string, errors: string[]}[]} Processed patterns
     */
    validateAndNormalizePatterns(patterns: string[]): {
        valid: string[];
        invalid: {
            pattern: string;
            errors: string[];
        }[];
    };
    /**
     * Check if a pattern is dangerous (could ignore important files)
     * @param pattern Pattern to check
     * @returns boolean True if pattern is dangerous
     */
    private isDangerousPattern;
    /**
     * Check if a pattern contains invalid characters
     * @param pattern Pattern to check
     * @returns boolean True if pattern has invalid characters
     */
    private hasInvalidCharacters;
    /**
     * Check if a pattern is overly broad
     * @param pattern Pattern to check
     * @returns boolean True if pattern is too broad
     */
    private isOverlyBroadPattern;
    /**
     * Check if a pattern is malformed
     * @param pattern Pattern to check
     * @returns boolean True if pattern is malformed
     */
    private isMalformedPattern;
    /**
     * Check if a pattern represents a directory
     * @param pattern Pattern to check
     * @returns boolean True if pattern is for a directory
     */
    private isDirectoryPattern;
    /**
     * Get validation rules for qraft patterns
     * @returns object Validation rules and descriptions
     */
    getValidationRules(): {
        rules: {
            name: string;
            description: string;
        }[];
        examples: {
            valid: string[];
            invalid: string[];
        };
    };
}
//# sourceMappingURL=qraftPatterns.d.ts.map