aiwg/dist/src/writing/pattern-library.d.ts

Deployment tool and support utility for AI context. Copies agents, skills, commands, rules, and behaviors into the paths each AI platform reads (Claude Code, Codex, Copilot, Cursor, Warp, OpenClaw, and 6 more) so one source of truth works across 10 platfo

/**
 * Pattern Library
 *
 * Comprehensive, categorized database of AI writing patterns with detection algorithms,
 * severity levels, and replacement suggestions.
 */
export type PatternCategory = 'banned-phrases' | 'formulaic-structures' | 'hedging-language' | 'transition-words' | 'weak-verbs' | 'passive-voice' | 'generic-adjectives' | 'list-structures' | 'conclusion-phrases' | 'introduction-phrases';
export type PatternSeverity = 'critical' | 'high' | 'medium' | 'low' | 'warning' | 'info';
export type PatternFrequency = 'very-common' | 'common' | 'occasional' | 'rare';
export type PatternDomain = 'academic' | 'technical' | 'executive' | 'casual';
export interface AIPattern {
    id: string;
    category: PatternCategory;
    subcategory?: string;
    pattern: string | RegExp;
    severity: PatternSeverity;
    confidence: number;
    examples: string[];
    replacements?: string[];
    context?: string;
    frequency: PatternFrequency;
    domains?: PatternDomain[];
}
export interface PatternMatch {
    pattern: AIPattern;
    match: string;
    position: {
        start: number;
        end: number;
    };
    context: string;
    severity: PatternSeverity;
}
export interface PatternFilter {
    categories?: PatternCategory[];
    severities?: PatternSeverity[];
    domains?: PatternDomain[];
    minConfidence?: number;
    maxConfidence?: number;
    frequencies?: PatternFrequency[];
    subcategories?: string[];
}
export interface PatternAnalysisResult {
    totalMatches: number;
    matchesByCategory: Map<PatternCategory, number>;
    matchesBySeverity: Map<PatternSeverity, number>;
    uniquePatterns: number;
    averageConfidence: number;
    criticalMatches: PatternMatch[];
    highPriorityMatches: PatternMatch[];
    wordCount: number;
    patternDensity: number;
}
export interface PatternComparisonResult {
    text1Matches: number;
    text2Matches: number;
    improvement: number;
    addedPatterns: PatternMatch[];
    removedPatterns: PatternMatch[];
    persistentPatterns: PatternMatch[];
}
/**
 * Pattern Library - Comprehensive AI pattern detection database
 */
export declare class PatternLibrary {
    private patterns;
    private patternsByCategory;
    private patternsBySeverity;
    private patternsById;
    private initialized;
    constructor();
    /**
     * Initialize the library by loading all patterns
     */
    initialize(): Promise<void>;
    /**
     * Get all patterns
     */
    getAllPatterns(): AIPattern[];
    /**
     * Get pattern by ID
     */
    getPatternById(id: string): AIPattern | undefined;
    /**
     * Get patterns by category
     */
    getPatternsByCategory(category: PatternCategory): AIPattern[];
    /**
     * Get patterns by severity
     */
    getPatternsBySeverity(severity: PatternSeverity): AIPattern[];
    /**
     * Get patterns by domain
     */
    getPatternsByDomain(domain: PatternDomain): AIPattern[];
    /**
     * Detect all patterns in text
     */
    detectPatterns(text: string): PatternMatch[];
    /**
     * Detect patterns by category
     */
    detectPatternsByCategory(text: string, category: PatternCategory): PatternMatch[];
    /**
     * Detect only critical patterns
     */
    detectCriticalPatterns(text: string): PatternMatch[];
    /**
     * Get pattern count
     */
    getPatternCount(): number;
    /**
     * Get pattern count by category
     */
    getPatternCountByCategory(): Map<PatternCategory, number>;
    /**
     * Get pattern count by severity
     */
    getPatternCountBySeverity(): Map<PatternSeverity, number>;
    /**
     * Add a new pattern
     */
    addPattern(pattern: AIPattern): void;
    /**
     * Remove a pattern by ID
     */
    removePattern(id: string): void;
    /**
     * Update a pattern
     */
    updatePattern(id: string, updates: Partial<AIPattern>): void;
    /**
     * Search patterns by query string
     */
    searchPatterns(query: string): AIPattern[];
    /**
     * Filter patterns by criteria
     */
    filterPatterns(filter: PatternFilter): AIPattern[];
    /**
     * Export patterns in various formats
     */
    exportPatterns(format: 'json' | 'yaml' | 'markdown'): string;
    /**
     * Import patterns from JSON or YAML
     */
    importPatterns(data: string, format: 'json' | 'yaml'): void;
    /**
     * Analyze text for AI patterns
     */
    analyzeText(text: string): PatternAnalysisResult;
    /**
     * Compare two texts for pattern changes
     */
    compareTexts(text1: string, text2: string): PatternComparisonResult;
    /**
     * Find all matches of a pattern in text
     */
    private findPatternMatches;
    /**
     * Create RegExp from pattern string
     */
    private createRegExpFromPattern;
    /**
     * Export patterns as markdown documentation
     */
    private exportAsMarkdown;
}
//# sourceMappingURL=pattern-library.d.ts.map