@ai-coders/context 0.1.0 → 0.2.1

package/dist/generators/guidelines/agentIntegration.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidelinesAgentIntegration = void 0;
+const agentGenerator_1 = require("../agents/agentGenerator");
+/**
+ * Integration layer between Guidelines Generator and Agent System
+ *
+ * This class leverages the existing agent system to enhance guideline generation
+ * by using specialized agents (architect-specialist, documentation-writer) to
+ * provide expert context and validation for generated guidelines.
+ */
+class GuidelinesAgentIntegration {
+    constructor(fileMapper, llmClient) {
+        this.fileMapper = fileMapper;
+        this.llmClient = llmClient;
+        this.agentGenerator = new agentGenerator_1.AgentGenerator(fileMapper, llmClient);
+    }
+    /**
+     * Enhance guideline generation using architect-specialist agent context
+     */
+    async enhanceWithArchitectAgent(repoStructure, moduleGroups, category) {
+        // The architect-specialist agent is perfect for:
+        // - architecture guidelines
+        // - performance guidelines
+        // - code-style guidelines
+        // - overall system design guidance
+        const architectContext = `Repository Analysis for ${category} Guidelines:
+
+Project Structure:
+${moduleGroups.map(m => `- ${m.name}: ${m.description} (${m.files.length} files)`).join('\n')}
+
+Focus Area: ${category}
+
+As an architect specialist, analyze this codebase and provide expert insights for creating ${category} guidelines that would be most valuable for this specific project structure and technology stack.
+
+Consider:
+1. Current architectural patterns evident in the codebase
+2. Areas where ${category} guidelines would have the most impact
+3. Technology-specific best practices for ${category}
+4. Common pitfalls to avoid in this type of project
+5. Specific recommendations for this codebase's current state
+
+Provide architectural insights that should be incorporated into ${category} guidelines.`;
+        return architectContext;
+    }
+    /**
+     * Enhance guideline generation using documentation-writer agent context
+     */
+    async enhanceWithDocumentationAgent(repoStructure, moduleGroups, category) {
+        // The documentation-writer agent is perfect for:
+        // - documentation guidelines
+        // - code-style guidelines (commenting, naming)
+        // - git-workflow guidelines (commit messages, PR descriptions)
+        // - general communication and knowledge sharing
+        const docContext = `Documentation Analysis for ${category} Guidelines:
+
+Current Documentation State:
+- Total Files: ${repoStructure.totalFiles}
+- README files: ${repoStructure.files.filter(f => f.relativePath.toLowerCase().includes('readme')).length}
+- Documentation directories: ${repoStructure.files.filter(f => f.relativePath.includes('docs') || f.relativePath.includes('doc')).length}
+
+Focus Area: ${category}
+
+As a documentation specialist, analyze how ${category} guidelines should be structured and presented to maximize their effectiveness for developers working on this codebase.
+
+Consider:
+1. How ${category} guidelines should be documented for best accessibility
+2. What examples and templates would be most helpful
+3. How to make guidelines actionable and measurable
+4. Integration with existing documentation patterns
+5. Onboarding and reference use cases
+
+Provide documentation expertise for creating effective ${category} guidelines.`;
+        return docContext;
+    }
+    /**
+     * Get agent-enhanced context for specific guideline categories
+     */
+    async getEnhancedContext(category, repoStructure, moduleGroups) {
+        const categoryAgentMap = {
+            'testing': 'architect',
+            'frontend': 'architect',
+            'backend': 'architect',
+            'database': 'architect',
+            'security': 'architect',
+            'performance': 'architect',
+            'code-style': 'both',
+            'git-workflow': 'documentation',
+            'deployment': 'architect',
+            'monitoring': 'architect',
+            'documentation': 'documentation',
+            'architecture': 'architect'
+        };
+        const agentApproach = categoryAgentMap[category];
+        const result = { recommendedAgentApproach: agentApproach };
+        if (agentApproach === 'architect' || agentApproach === 'both') {
+            result.architectContext = await this.enhanceWithArchitectAgent(repoStructure, moduleGroups, category);
+        }
+        if (agentApproach === 'documentation' || agentApproach === 'both') {
+            result.documentationContext = await this.enhanceWithDocumentationAgent(repoStructure, moduleGroups, category);
+        }
+        return result;
+    }
+    /**
+     * Generate agent prompts specifically for guideline validation and enhancement
+     */
+    async generateGuidelineValidationPrompts(repoStructure, outputDir, verbose = false) {
+        // Generate specialized agent prompts for guideline creation and validation
+        await this.agentGenerator.generateAgentPrompts(repoStructure, outputDir, verbose);
+    }
+    /**
+     * Create guideline-specific agent prompt that combines multiple agent perspectives
+     */
+    createCombinedAgentPrompt(category, architectContext, documentationContext) {
+        let prompt = `# Guidelines Creation Agent for ${category.toUpperCase()}
+
+You are a specialized AI agent focused on creating comprehensive ${category} guidelines.
+
+## Your Role
+Combine the expertise of both architect and documentation specialists to create actionable, practical guidelines for ${category}.
+
+`;
+        if (architectContext) {
+            prompt += `## Architectural Perspective
+${architectContext}
+
+`;
+        }
+        if (documentationContext) {
+            prompt += `## Documentation Perspective  
+${documentationContext}
+
+`;
+        }
+        prompt += `## Your Task
+Create detailed, actionable ${category} guidelines that:
+
+1. **Are Specific**: Tailored to this exact codebase and technology stack
+2. **Are Actionable**: Provide clear steps and decisions developers can follow
+3. **Are Measurable**: Include ways to verify adherence to guidelines
+4. **Are Practical**: Focus on real-world development scenarios
+5. **Are Maintainable**: Can evolve with the project over time
+
+## Guidelines Structure
+For each guideline, provide:
+- **Rule**: Clear, concise statement of what to do
+- **Rationale**: Why this rule matters for this specific project
+- **Examples**: Concrete examples using the project's technology stack
+- **Tools**: Specific tools or automation to support the guideline
+- **Validation**: How to check if the guideline is being followed
+
+Focus on guidelines that will have the highest impact on code quality, team productivity, and project maintainability.`;
+        return prompt;
+    }
+}
+exports.GuidelinesAgentIntegration = GuidelinesAgentIntegration;
+//# sourceMappingURL=agentIntegration.js.map

package/dist/generators/guidelines/agentIntegration.js.map

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

package/dist/generators/guidelines/guidelineTypes.d.ts

@@ -0,0 +1,40 @@
+export declare const GUIDELINE_CATEGORIES: readonly ["testing", "frontend", "backend", "database", "security", "performance", "code-style", "git-workflow", "deployment", "monitoring", "documentation", "architecture"];
+export type GuidelineCategory = typeof GUIDELINE_CATEGORIES[number];
+export declare const GUIDELINE_CATEGORIES_ARRAY: GuidelineCategory[];
+export interface GuidelineConfig {
+    categories: GuidelineCategory[];
+    techStack: string[];
+    projectType: 'frontend' | 'backend' | 'fullstack' | 'library' | 'cli' | 'mobile';
+    complexity: 'simple' | 'moderate' | 'complex';
+    teamSize: 'solo' | 'small' | 'medium' | 'large';
+    includeExamples: boolean;
+    includeTools: boolean;
+}
+export interface DetectedTechnology {
+    name: string;
+    category: 'framework' | 'library' | 'database' | 'tool' | 'language';
+    confidence: number;
+    files: string[];
+    patterns: string[];
+}
+export interface GuidelineRule {
+    rule: string;
+    rationale: string;
+    examples?: string[];
+    antiPatterns?: string[];
+    tools?: string[];
+    severity: 'must' | 'should' | 'could';
+}
+export interface GuidelineSection {
+    title: string;
+    description: string;
+    rules: GuidelineRule[];
+    relatedCategories?: GuidelineCategory[];
+}
+export declare const TECHNOLOGY_PATTERNS: Record<string, {
+    files: string[];
+    dependencies?: string[];
+    patterns?: string[];
+    category: DetectedTechnology['category'];
+}>;
+//# sourceMappingURL=guidelineTypes.d.ts.map

package/dist/generators/guidelines/guidelineTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidelineTypes.d.ts","sourceRoot":"","sources":["../../../src/generators/guidelines/guidelineTypes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,+KAavB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAEpE,eAAO,MAAM,0BAA0B,EAAE,iBAAiB,EAA8B,CAAC;AAEzF,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;IACjF,UAAU,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IAC9C,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IAChD,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,CAAC;IACrE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,iBAAiB,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACzC;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE;IAC/C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;CAC1C,CAkIA,CAAC"}

package/dist/generators/guidelines/guidelineTypes.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TECHNOLOGY_PATTERNS = exports.GUIDELINE_CATEGORIES_ARRAY = exports.GUIDELINE_CATEGORIES = void 0;
+exports.GUIDELINE_CATEGORIES = [
+    'testing',
+    'frontend',
+    'backend',
+    'database',
+    'security',
+    'performance',
+    'code-style',
+    'git-workflow',
+    'deployment',
+    'monitoring',
+    'documentation',
+    'architecture'
+];
+exports.GUIDELINE_CATEGORIES_ARRAY = [...exports.GUIDELINE_CATEGORIES];
+exports.TECHNOLOGY_PATTERNS = {
+    // Frontend Frameworks
+    'React': {
+        files: ['package.json', '*.jsx', '*.tsx'],
+        dependencies: ['react', '@types/react'],
+        patterns: ['useState', 'useEffect', 'Component'],
+        category: 'framework'
+    },
+    'Vue': {
+        files: ['package.json', '*.vue'],
+        dependencies: ['vue', '@vue/'],
+        patterns: ['<template>', '<script>', '<style>'],
+        category: 'framework'
+    },
+    'Angular': {
+        files: ['package.json', '*.component.ts', 'angular.json'],
+        dependencies: ['@angular/'],
+        patterns: ['@Component', '@Injectable', '@NgModule'],
+        category: 'framework'
+    },
+    'Next.js': {
+        files: ['package.json', 'next.config.js', 'pages/', 'app/'],
+        dependencies: ['next'],
+        patterns: ['getServerSideProps', 'getStaticProps'],
+        category: 'framework'
+    },
+    // Backend Frameworks
+    'Express': {
+        files: ['package.json', '*.js', '*.ts'],
+        dependencies: ['express', '@types/express'],
+        patterns: ['app.get', 'app.post', 'middleware'],
+        category: 'framework'
+    },
+    'Fastify': {
+        files: ['package.json'],
+        dependencies: ['fastify'],
+        patterns: ['fastify.register', 'fastify.get'],
+        category: 'framework'
+    },
+    'NestJS': {
+        files: ['package.json', '*.controller.ts', '*.service.ts'],
+        dependencies: ['@nestjs/'],
+        patterns: ['@Controller', '@Injectable', '@Module'],
+        category: 'framework'
+    },
+    // Databases
+    'MongoDB': {
+        files: ['package.json'],
+        dependencies: ['mongodb', 'mongoose'],
+        patterns: ['Schema', 'Model', 'connect'],
+        category: 'database'
+    },
+    'PostgreSQL': {
+        files: ['package.json', '*.sql'],
+        dependencies: ['pg', 'postgres', 'prisma'],
+        patterns: ['SELECT', 'INSERT', 'CREATE TABLE'],
+        category: 'database'
+    },
+    'Redis': {
+        files: ['package.json'],
+        dependencies: ['redis', 'ioredis'],
+        patterns: ['redis.get', 'redis.set'],
+        category: 'database'
+    },
+    // Testing Frameworks
+    'Jest': {
+        files: ['package.json', '*.test.js', '*.test.ts', 'jest.config.js'],
+        dependencies: ['jest', '@types/jest'],
+        patterns: ['describe', 'it', 'expect'],
+        category: 'tool'
+    },
+    'Cypress': {
+        files: ['package.json', 'cypress.config.js', 'cypress/'],
+        dependencies: ['cypress'],
+        patterns: ['cy.visit', 'cy.get', 'cy.click'],
+        category: 'tool'
+    },
+    'Vitest': {
+        files: ['package.json', 'vitest.config.ts'],
+        dependencies: ['vitest'],
+        patterns: ['describe', 'it', 'expect'],
+        category: 'tool'
+    },
+    // Build Tools
+    'Webpack': {
+        files: ['webpack.config.js', 'package.json'],
+        dependencies: ['webpack'],
+        patterns: ['module.exports', 'entry:', 'output:'],
+        category: 'tool'
+    },
+    'Vite': {
+        files: ['vite.config.ts', 'vite.config.js', 'package.json'],
+        dependencies: ['vite'],
+        patterns: ['defineConfig', 'plugins:', 'build:'],
+        category: 'tool'
+    },
+    // Languages
+    'TypeScript': {
+        files: ['tsconfig.json', '*.ts', '*.tsx'],
+        dependencies: ['typescript', '@types/'],
+        patterns: ['interface', 'type', 'enum'],
+        category: 'language'
+    },
+    'Python': {
+        files: ['*.py', 'requirements.txt', 'pyproject.toml'],
+        patterns: ['def ', 'class ', 'import '],
+        category: 'language'
+    },
+    'Go': {
+        files: ['*.go', 'go.mod'],
+        patterns: ['func ', 'package ', 'import ('],
+        category: 'language'
+    },
+    // DevOps/Deployment
+    'Docker': {
+        files: ['Dockerfile', 'docker-compose.yml', '.dockerignore'],
+        patterns: ['FROM ', 'RUN ', 'COPY '],
+        category: 'tool'
+    },
+    'Kubernetes': {
+        files: ['*.yaml', '*.yml'],
+        patterns: ['apiVersion:', 'kind:', 'metadata:'],
+        category: 'tool'
+    }
+};
+//# sourceMappingURL=guidelineTypes.js.map

package/dist/generators/guidelines/guidelineTypes.js.map

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

package/dist/generators/guidelines/guidelinesAnalyzer.d.ts

@@ -0,0 +1,30 @@
+import { RepoStructure } from '../../types';
+import { FileMapper } from '../../utils/fileMapper';
+import { GuidelineCategory, DetectedTechnology, GuidelineConfig } from './guidelineTypes';
+export declare class GuidelinesAnalyzer {
+    private fileMapper;
+    constructor(fileMapper: FileMapper);
+    analyzeCodebase(repoStructure: RepoStructure): Promise<{
+        technologies: DetectedTechnology[];
+        projectType: GuidelineConfig['projectType'];
+        complexity: GuidelineConfig['complexity'];
+        recommendedCategories: GuidelineCategory[];
+        techStack: string[];
+    }>;
+    detectTechnologies(repoStructure: RepoStructure): Promise<DetectedTechnology[]>;
+    private detectTechnology;
+    private checkFilePatterns;
+    private checkDependencies;
+    private checkCodePatterns;
+    private matchesPattern;
+    private determineProjectType;
+    private assessComplexity;
+    private recommendCategories;
+    analyzeTestingPatterns(repoStructure: RepoStructure): Promise<{
+        testFrameworks: string[];
+        testPatterns: string[];
+        coverageTools: string[];
+        testTypes: string[];
+    }>;
+}
+//# sourceMappingURL=guidelinesAnalyzer.d.ts.map

package/dist/generators/guidelines/guidelinesAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guidelinesAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/generators/guidelines/guidelinesAnalyzer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAY,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,kBAAkB;IACjB,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEpC,eAAe,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC;QAC3D,YAAY,EAAE,kBAAkB,EAAE,CAAC;QACnC,WAAW,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;QAC5C,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;QAC1C,qBAAqB,EAAE,iBAAiB,EAAE,CAAC;QAC3C,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;IAgBI,kBAAkB,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;YAavE,gBAAgB;IA2C9B,OAAO,CAAC,iBAAiB;YAcX,iBAAiB;YAiCjB,iBAAiB;IAuB/B,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,oBAAoB;IA8B5B,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,mBAAmB;IA4CrB,sBAAsB,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC;QAClE,cAAc,EAAE,MAAM,EAAE,CAAC;QACzB,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CA2CH"}

package/dist/generators/guidelines/guidelinesAnalyzer.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidelinesAnalyzer = void 0;
+const guidelineTypes_1 = require("./guidelineTypes");
+class GuidelinesAnalyzer {
+    constructor(fileMapper) {
+        this.fileMapper = fileMapper;
+    }
+    async analyzeCodebase(repoStructure) {
+        const technologies = await this.detectTechnologies(repoStructure);
+        const projectType = this.determineProjectType(repoStructure, technologies);
+        const complexity = this.assessComplexity(repoStructure, technologies);
+        const recommendedCategories = this.recommendCategories(technologies, projectType);
+        const techStack = technologies.map(t => t.name);
+        return {
+            technologies,
+            projectType,
+            complexity,
+            recommendedCategories,
+            techStack
+        };
+    }
+    async detectTechnologies(repoStructure) {
+        const detectedTech = [];
+        for (const [techName, pattern] of Object.entries(guidelineTypes_1.TECHNOLOGY_PATTERNS)) {
+            const detection = await this.detectTechnology(techName, pattern, repoStructure);
+            if (detection.confidence > 0.3) { // Only include if confidence > 30%
+                detectedTech.push(detection);
+            }
+        }
+        return detectedTech.sort((a, b) => b.confidence - a.confidence);
+    }
+    async detectTechnology(techName, pattern, repoStructure) {
+        let confidence = 0;
+        const matchingFiles = [];
+        const foundPatterns = [];
+        // Check file patterns
+        const fileMatches = this.checkFilePatterns(pattern.files, repoStructure.files);
+        if (fileMatches.length > 0) {
+            confidence += 0.4;
+            matchingFiles.push(...fileMatches);
+        }
+        // Check dependencies
+        if (pattern.dependencies) {
+            const depMatches = await this.checkDependencies(pattern.dependencies, repoStructure);
+            if (depMatches.length > 0) {
+                confidence += 0.5;
+                foundPatterns.push(...depMatches);
+            }
+        }
+        // Check code patterns
+        if (pattern.patterns) {
+            const codeMatches = await this.checkCodePatterns(pattern.patterns, repoStructure, matchingFiles);
+            if (codeMatches.length > 0) {
+                confidence += 0.3;
+                foundPatterns.push(...codeMatches);
+            }
+        }
+        return {
+            name: techName,
+            category: pattern.category,
+            confidence: Math.min(confidence, 1.0),
+            files: matchingFiles,
+            patterns: foundPatterns
+        };
+    }
+    checkFilePatterns(patterns, files) {
+        const matches = [];
+        for (const pattern of patterns) {
+            for (const file of files) {
+                if (this.matchesPattern(file.relativePath, pattern)) {
+                    matches.push(file.relativePath);
+                }
+            }
+        }
+        return [...new Set(matches)]; // Remove duplicates
+    }
+    async checkDependencies(dependencies, repoStructure) {
+        const packageJsonFiles = repoStructure.files.filter(f => f.relativePath.endsWith('package.json'));
+        const foundDeps = [];
+        for (const pkgFile of packageJsonFiles) {
+            try {
+                const content = await this.fileMapper.readFileContent(pkgFile.path);
+                const pkg = JSON.parse(content);
+                const allDeps = {
+                    ...pkg.dependencies,
+                    ...pkg.devDependencies,
+                    ...pkg.peerDependencies
+                };
+                for (const dep of dependencies) {
+                    for (const depName of Object.keys(allDeps)) {
+                        if (depName.includes(dep) || dep.includes(depName)) {
+                            foundDeps.push(depName);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // Skip invalid package.json files
+            }
+        }
+        return [...new Set(foundDeps)];
+    }
+    async checkCodePatterns(patterns, repoStructure, relevantFiles) {
+        const foundPatterns = [];
+        const filesToCheck = relevantFiles.length > 0
+            ? repoStructure.files.filter(f => relevantFiles.includes(f.relativePath))
+            : repoStructure.files.slice(0, 20); // Sample files if no relevant files specified
+        for (const file of filesToCheck) {
+            try {
+                const content = await this.fileMapper.readFileContent(file.path);
+                for (const pattern of patterns) {
+                    if (content.includes(pattern)) {
+                        foundPatterns.push(pattern);
+                    }
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        return [...new Set(foundPatterns)];
+    }
+    matchesPattern(filePath, pattern) {
+        // Convert glob-like patterns to regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(regexPattern, 'i');
+        return regex.test(filePath) || filePath.includes(pattern.replace('*', ''));
+    }
+    determineProjectType(repoStructure, technologies) {
+        const hasBackend = technologies.some(t => ['Express', 'Fastify', 'NestJS'].includes(t.name) ||
+            t.category === 'database');
+        const hasFrontend = technologies.some(t => ['React', 'Vue', 'Angular', 'Next.js'].includes(t.name));
+        const hasCLI = repoStructure.files.some(f => f.relativePath.includes('bin/') ||
+            f.relativePath.includes('cli') ||
+            f.relativePath.includes('command'));
+        const hasLib = repoStructure.files.some(f => f.relativePath === 'index.ts' ||
+            f.relativePath === 'lib/index.ts');
+        if (hasCLI)
+            return 'cli';
+        if (hasLib && !hasFrontend && !hasBackend)
+            return 'library';
+        if (hasFrontend && hasBackend)
+            return 'fullstack';
+        if (hasFrontend)
+            return 'frontend';
+        if (hasBackend)
+            return 'backend';
+        return 'library'; // Default fallback
+    }
+    assessComplexity(repoStructure, technologies) {
+        const fileCount = repoStructure.totalFiles;
+        const techCount = technologies.length;
+        const hasMultipleFrameworks = technologies.filter(t => t.category === 'framework').length > 1;
+        const hasDatabase = technologies.some(t => t.category === 'database');
+        const hasDeployment = technologies.some(t => ['Docker', 'Kubernetes'].includes(t.name));
+        let complexityScore = 0;
+        // File count scoring
+        if (fileCount > 200)
+            complexityScore += 3;
+        else if (fileCount > 50)
+            complexityScore += 2;
+        else
+            complexityScore += 1;
+        // Technology diversity scoring
+        if (techCount > 10)
+            complexityScore += 3;
+        else if (techCount > 5)
+            complexityScore += 2;
+        else
+            complexityScore += 1;
+        // Architecture complexity
+        if (hasMultipleFrameworks)
+            complexityScore += 2;
+        if (hasDatabase)
+            complexityScore += 1;
+        if (hasDeployment)
+            complexityScore += 2;
+        if (complexityScore >= 8)
+            return 'complex';
+        if (complexityScore >= 5)
+            return 'moderate';
+        return 'simple';
+    }
+    recommendCategories(technologies, projectType) {
+        const categories = new Set();
+        // Always include these basic categories
+        categories.add('code-style');
+        categories.add('git-workflow');
+        categories.add('documentation');
+        // Add testing if testing framework detected
+        if (technologies.some(t => ['Jest', 'Cypress', 'Vitest'].includes(t.name))) {
+            categories.add('testing');
+        }
+        // Frontend-specific categories
+        if (projectType === 'frontend' || projectType === 'fullstack') {
+            categories.add('frontend');
+            categories.add('performance');
+        }
+        // Backend-specific categories
+        if (projectType === 'backend' || projectType === 'fullstack') {
+            categories.add('backend');
+            categories.add('security');
+            categories.add('monitoring');
+        }
+        // Database categories
+        if (technologies.some(t => t.category === 'database')) {
+            categories.add('database');
+        }
+        // Deployment categories
+        if (technologies.some(t => ['Docker', 'Kubernetes'].includes(t.name))) {
+            categories.add('deployment');
+        }
+        // Architecture for complex projects
+        if (technologies.length > 5 || projectType === 'fullstack') {
+            categories.add('architecture');
+        }
+        return Array.from(categories);
+    }
+    async analyzeTestingPatterns(repoStructure) {
+        const testFiles = repoStructure.files.filter(f => f.relativePath.includes('test') ||
+            f.relativePath.includes('spec') ||
+            f.relativePath.includes('__tests__'));
+        const testFrameworks = [];
+        const testPatterns = [];
+        const coverageTools = [];
+        const testTypes = [];
+        // Detect test frameworks
+        for (const file of testFiles.slice(0, 10)) {
+            try {
+                const content = await this.fileMapper.readFileContent(file.path);
+                if (content.includes('describe') && content.includes('it')) {
+                    testFrameworks.push('Jest/Mocha-style');
+                }
+                if (content.includes('cy.')) {
+                    testFrameworks.push('Cypress');
+                    testTypes.push('E2E Testing');
+                }
+                if (content.includes('render(') && content.includes('screen.')) {
+                    testFrameworks.push('React Testing Library');
+                    testTypes.push('Component Testing');
+                }
+                if (content.includes('mount(') || content.includes('shallow(')) {
+                    testFrameworks.push('Enzyme');
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        return {
+            testFrameworks: [...new Set(testFrameworks)],
+            testPatterns: [...new Set(testPatterns)],
+            coverageTools: [...new Set(coverageTools)],
+            testTypes: [...new Set(testTypes)]
+        };
+    }
+}
+exports.GuidelinesAnalyzer = GuidelinesAnalyzer;
+//# sourceMappingURL=guidelinesAnalyzer.js.map