stringray-ai 1.0.0

package/dist/plugin/logging-config.js

@@ -0,0 +1,44 @@
+// Default logging configuration
+const defaultLoggingConfig = {
+    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.STRRAY_LOG_LEVEL || "info",
+    destinations: ["console", "file"],
+    performanceMode: process.env.STRRAY_PERFORMANCE_MODE === "true",
+};
+// Available log levels in priority order (higher index = more verbose)
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+// Global logging configuration instance
+let globalLoggingConfig = { ...defaultLoggingConfig };
+export function getLoggingConfig() {
+    return { ...globalLoggingConfig };
+}
+export function setLoggingConfig(config) {
+    globalLoggingConfig = { ...globalLoggingConfig, ...config };
+}
+export function isLoggingEnabled() {
+    return globalLoggingConfig.enabled;
+}
+export function shouldLog(level) {
+    if (!globalLoggingConfig.enabled) {
+        return false;
+    }
+    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
+    const messageLevelIndex = LOG_LEVELS.indexOf(level);
+    // If either level is not found, default to showing the message
+    if (currentLevelIndex === -1 || messageLevelIndex === -1) {
+        return true;
+    }
+    // Show message if its level is >= current configured level
+    return messageLevelIndex >= currentLevelIndex;
+}
+// Environment variable configuration
+if (process.env.STRRAY_LOGGING_ENABLED === "false") {
+    setLoggingConfig({ enabled: false });
+}
+if (process.env.STRRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+}
+if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+    setLoggingConfig({ performanceMode: true });
+}
+//# sourceMappingURL=logging-config.js.map

package/dist/plugin/logging-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-config.js","sourceRoot":"","sources":["../../src/logging-config.ts"],"names":[],"mappings":"AAQA,gCAAgC;AAChC,MAAM,oBAAoB,GAAkB;IAC1C,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,sBAAsB,KAAK,OAAO,EAAE,gCAAgC;IACzF,KAAK,EAAG,OAAO,CAAC,GAAG,CAAC,gBAAwB,IAAI,MAAM;IACtD,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,MAAM;CAChE,CAAC;AAEF,uEAAuE;AACvE,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtD,wCAAwC;AACxC,IAAI,mBAAmB,GAAkB,EAAE,GAAG,oBAAoB,EAAE,CAAC;AAErE,MAAM,UAAU,gBAAgB;IAC9B,OAAO,EAAE,GAAG,mBAAmB,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,MAA8B;IAC7D,mBAAmB,GAAG,EAAE,GAAG,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAAC;AAC9D,CAAC;AAED,MAAM,UAAU,gBAAgB;IAC9B,OAAO,mBAAmB,CAAC,OAAO,CAAC;AACrC,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,CAAC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACxE,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAEpD,+DAA+D;IAC/D,IAAI,iBAAiB,KAAK,CAAC,CAAC,IAAI,iBAAiB,KAAK,CAAC,CAAC,EAAE,CAAC;QACzD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,2DAA2D;IAC3D,OAAO,iBAAiB,IAAI,iBAAiB,CAAC;AAChD,CAAC;AAED,qCAAqC;AACrC,IAAI,OAAO,CAAC,GAAG,CAAC,sBAAsB,KAAK,OAAO,EAAE,CAAC;IACnD,gBAAgB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;IACjC,gBAAgB,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,gBAAuB,EAAE,CAAC,CAAC;AACnE,CAAC;AAED,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,MAAM,EAAE,CAAC;IACnD,gBAAgB,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9C,CAAC"}

package/dist/plugin/mcps/architect-tools.server.d.ts

@@ -0,0 +1,40 @@
+/**
+ * StrRay Architect Tools MCP Server
+ *
+ * Converts architect-tools.ts functions into MCP server tools
+ * Provides contextual analysis capabilities via MCP protocol
+ */
+declare class StrRayArchitectToolsServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private contextAnalysis;
+    private codebaseStructure;
+    private dependencyAnalysis;
+    private architectureAssessment;
+    private analyzeProjectStructure;
+    private identifyPatterns;
+    private assessComplexity;
+    private mapDependencies;
+    private buildDirectoryHierarchy;
+    private calculateStructureMetrics;
+    private analyzeDependencies;
+    private assessCoupling;
+    private detectCircularDependencies;
+    private generateDependencyGraphs;
+    private generateDependencyRecommendations;
+    private calculateArchitecturalScores;
+    private identifyArchitecturalIssues;
+    private recognizeArchitecturalPatterns;
+    private generateArchitecturalRecommendations;
+    private calculateOverallHealthScore;
+    private getProjectFiles;
+    private getProjectDirectories;
+    private groupByExtension;
+    private calculateMaxDepth;
+    private extractImports;
+    private shouldIgnorePath;
+    run(): Promise<void>;
+}
+export default StrRayArchitectToolsServer;
+//# sourceMappingURL=architect-tools.server.d.ts.map

package/dist/plugin/mcps/architect-tools.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"architect-tools.server.d.ts","sourceRoot":"","sources":["../../../src/mcps/architect-tools.server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAWH,cAAM,0BAA0B;IAC9B,OAAO,CAAC,MAAM,CAAS;;IAmBvB,OAAO,CAAC,iBAAiB;YAgJX,eAAe;YAgCf,iBAAiB;YA0BjB,kBAAkB;YA8BlB,sBAAsB;YAsCtB,uBAAuB;YAgBvB,gBAAgB;YAiBhB,gBAAgB;YA6BhB,eAAe;YAwBf,uBAAuB;YA2CvB,yBAAyB;YAczB,mBAAmB;YA+BnB,cAAc;YAUd,0BAA0B;YAO1B,wBAAwB;YAKxB,iCAAiC;YAUjC,4BAA4B;YAa5B,2BAA2B;YAa3B,8BAA8B;YAgB9B,oCAAoC;YAUpC,2BAA2B;YAQ3B,eAAe;YAyBf,qBAAqB;IAwBnC,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,gBAAgB;IAoBlB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAK3B;AAOD,eAAe,0BAA0B,CAAC"}

package/dist/plugin/mcps/architect-tools.server.js

@@ -0,0 +1,563 @@
+/**
+ * StrRay Architect Tools MCP Server
+ *
+ * Converts architect-tools.ts functions into MCP server tools
+ * Provides contextual analysis capabilities via MCP protocol
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+class StrRayArchitectToolsServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "strray-architect-tools",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        console.log("StrRay Architect Tools MCP Server initialized");
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "context-analysis",
+                        description: "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                projectRoot: {
+                                    type: "string",
+                                    description: "Root directory of the project to analyze",
+                                },
+                                depth: {
+                                    type: "string",
+                                    enum: ["overview", "detailed", "comprehensive"],
+                                    default: "detailed",
+                                    description: "Analysis depth level",
+                                },
+                                includeFiles: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Specific files to include in analysis",
+                                },
+                            },
+                            required: ["projectRoot"],
+                        },
+                    },
+                    {
+                        name: "codebase-structure",
+                        description: "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                projectRoot: {
+                                    type: "string",
+                                    description: "Root directory of the project",
+                                },
+                                includeMetrics: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Include detailed metrics",
+                                },
+                                maxDepth: {
+                                    type: "number",
+                                    default: 10,
+                                    description: "Maximum directory depth to analyze",
+                                },
+                            },
+                            required: ["projectRoot"],
+                        },
+                    },
+                    {
+                        name: "dependency-analysis",
+                        description: "Map component dependencies, identify coupling patterns, and assess architectural relationships",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                projectRoot: {
+                                    type: "string",
+                                    description: "Root directory of the project",
+                                },
+                                focusAreas: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Specific areas to focus dependency analysis on",
+                                },
+                                includeGraphs: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Include dependency graphs in output",
+                                },
+                            },
+                            required: ["projectRoot"],
+                        },
+                    },
+                    {
+                        name: "architecture-assessment",
+                        description: "Evaluate overall architectural health with scores, issues, and improvement recommendations",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                projectRoot: {
+                                    type: "string",
+                                    description: "Root directory of the project",
+                                },
+                                assessmentType: {
+                                    type: "string",
+                                    enum: ["quick", "comprehensive"],
+                                    default: "comprehensive",
+                                    description: "Type of assessment to perform",
+                                },
+                                focusMetrics: {
+                                    type: "array",
+                                    items: {
+                                        type: "string",
+                                        enum: [
+                                            "complexity",
+                                            "coupling",
+                                            "cohesion",
+                                            "testability",
+                                            "scalability",
+                                        ],
+                                    },
+                                    description: "Specific metrics to focus assessment on",
+                                },
+                            },
+                            required: ["projectRoot"],
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "context-analysis":
+                        return await this.contextAnalysis(args);
+                    case "codebase-structure":
+                        return await this.codebaseStructure(args);
+                    case "dependency-analysis":
+                        return await this.dependencyAnalysis(args);
+                    case "architecture-assessment":
+                        return await this.architectureAssessment(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                console.error(`Error in architect tool ${name}:`, error);
+                throw error;
+            }
+        });
+    }
+    // Tool implementations - wrappers around the original architect-tools functions
+    async contextAnalysis(args) {
+        const { projectRoot, depth = "detailed", includeFiles } = args;
+        console.log(`🏗️ Architect Tool: Performing context analysis on ${projectRoot}`);
+        // This would integrate with the actual architect-tools.ts functions
+        // For now, providing a simplified implementation
+        const result = {
+            projectRoot,
+            depth,
+            analysis: {
+                structure: await this.analyzeProjectStructure(projectRoot),
+                patterns: await this.identifyPatterns(projectRoot),
+                complexity: await this.assessComplexity(projectRoot),
+                dependencies: await this.mapDependencies(projectRoot),
+            },
+            filesAnalyzed: includeFiles || (await this.getProjectFiles(projectRoot)),
+            timestamp: new Date().toISOString(),
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async codebaseStructure(args) {
+        const { projectRoot, includeMetrics = true, maxDepth = 10 } = args;
+        console.log(`🏗️ Architect Tool: Analyzing codebase structure for ${projectRoot}`);
+        const structure = {
+            projectRoot,
+            hierarchy: await this.buildDirectoryHierarchy(projectRoot, maxDepth),
+            metrics: includeMetrics
+                ? await this.calculateStructureMetrics(projectRoot)
+                : undefined,
+            analyzedAt: new Date().toISOString(),
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(structure, null, 2),
+                },
+            ],
+        };
+    }
+    async dependencyAnalysis(args) {
+        const { projectRoot, focusAreas, includeGraphs = true } = args;
+        console.log(`🏗️ Architect Tool: Performing dependency analysis on ${projectRoot}`);
+        const analysis = {
+            projectRoot,
+            dependencies: await this.analyzeDependencies(projectRoot, focusAreas),
+            coupling: await this.assessCoupling(projectRoot),
+            circularDeps: await this.detectCircularDependencies(projectRoot),
+            graphs: includeGraphs
+                ? await this.generateDependencyGraphs(projectRoot)
+                : undefined,
+            recommendations: await this.generateDependencyRecommendations(projectRoot),
+            analyzedAt: new Date().toISOString(),
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(analysis, null, 2),
+                },
+            ],
+        };
+    }
+    async architectureAssessment(args) {
+        const { projectRoot, assessmentType = "comprehensive", focusMetrics, } = args;
+        console.log(`🏗️ Architect Tool: Performing architecture assessment on ${projectRoot}`);
+        const assessment = {
+            projectRoot,
+            assessmentType,
+            scores: await this.calculateArchitecturalScores(projectRoot, focusMetrics),
+            issues: await this.identifyArchitecturalIssues(projectRoot),
+            patterns: await this.recognizeArchitecturalPatterns(projectRoot),
+            recommendations: await this.generateArchitecturalRecommendations(projectRoot),
+            healthScore: await this.calculateOverallHealthScore(projectRoot),
+            analyzedAt: new Date().toISOString(),
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(assessment, null, 2),
+                },
+            ],
+        };
+    }
+    // Implementation helpers (simplified versions of the actual architect-tools logic)
+    async analyzeProjectStructure(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        const directories = await this.getProjectDirectories(projectRoot);
+        return {
+            totalFiles: files.length,
+            totalDirectories: directories.length,
+            fileTypes: this.groupByExtension(files),
+            directoryDepth: this.calculateMaxDepth(directories),
+            largestFiles: files
+                .map((f) => ({ path: f, size: fs.statSync(f).size }))
+                .sort((a, b) => b.size - a.size)
+                .slice(0, 5),
+        };
+    }
+    async identifyPatterns(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        const patterns = [];
+        // Simple pattern detection
+        const hasControllers = files.some((f) => f.includes("controller"));
+        const hasServices = files.some((f) => f.includes("service"));
+        const hasModels = files.some((f) => f.includes("model"));
+        if (hasControllers && hasModels)
+            patterns.push("MVC Pattern");
+        if (hasServices)
+            patterns.push("Service Layer");
+        if (files.some((f) => f.includes("repository")))
+            patterns.push("Repository Pattern");
+        return patterns;
+    }
+    async assessComplexity(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        let totalComplexity = 0;
+        let totalLines = 0;
+        for (const file of files.slice(0, 20)) {
+            // Sample for performance
+            try {
+                const content = fs.readFileSync(file, "utf8");
+                const lines = content.split("\n").length;
+                const complexity = Math.floor(lines / 50) + 1; // Simple heuristic
+                totalComplexity += complexity;
+                totalLines += lines;
+            }
+            catch (error) {
+                // Skip unreadable files
+            }
+        }
+        return {
+            averageComplexity: totalComplexity / Math.max(1, Math.min(files.length, 20)),
+            totalLinesOfCode: totalLines,
+            estimatedFunctions: Math.floor(totalLines / 20), // Rough estimate
+            estimatedClasses: Math.floor(totalLines / 100),
+        };
+    }
+    async mapDependencies(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        const dependencies = {};
+        for (const file of files.slice(0, 10)) {
+            // Sample for performance
+            try {
+                const content = fs.readFileSync(file, "utf8");
+                const imports = this.extractImports(content);
+                dependencies[file] = imports;
+            }
+            catch (error) {
+                dependencies[file] = [];
+            }
+        }
+        return {
+            dependencyMap: dependencies,
+            totalDependencies: Object.values(dependencies).flat().length,
+            averageDependenciesPerFile: Object.values(dependencies).flat().length /
+                Object.keys(dependencies).length,
+        };
+    }
+    async buildDirectoryHierarchy(projectRoot, maxDepth) {
+        const traverse = (dirPath, currentDepth) => {
+            if (currentDepth >= maxDepth)
+                return { truncated: true };
+            try {
+                const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                const result = {
+                    name: path.basename(dirPath),
+                    path: path.relative(projectRoot, dirPath),
+                    type: "directory",
+                    children: [],
+                };
+                for (const entry of entries) {
+                    if (this.shouldIgnorePath(path.join(dirPath, entry.name)))
+                        continue;
+                    if (entry.isDirectory()) {
+                        result.children.push(traverse(path.join(dirPath, entry.name), currentDepth + 1));
+                    }
+                    else {
+                        result.children.push({
+                            name: entry.name,
+                            type: "file",
+                            extension: path.extname(entry.name),
+                        });
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                return {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        };
+        return traverse(projectRoot, 0);
+    }
+    async calculateStructureMetrics(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        return {
+            totalFiles: files.length,
+            fileTypeDistribution: this.groupByExtension(files),
+            averageFileSize: files.reduce((sum, f) => sum + fs.statSync(f).size, 0) / files.length,
+            largestFile: files
+                .map((f) => ({ path: f, size: fs.statSync(f).size }))
+                .sort((a, b) => b.size - a.size)[0],
+        };
+    }
+    async analyzeDependencies(projectRoot, focusAreas) {
+        const files = await this.getProjectFiles(projectRoot);
+        // Simple dependency analysis
+        const dependencies = {};
+        let circularDeps = 0;
+        for (const file of files.slice(0, 10)) {
+            try {
+                const content = fs.readFileSync(file, "utf8");
+                dependencies[file] = this.extractImports(content);
+            }
+            catch (error) {
+                dependencies[file] = [];
+            }
+        }
+        return {
+            totalDependencies: Object.values(dependencies).flat().length,
+            uniqueDependencies: Array.from(new Set(Object.values(dependencies).flat())).length,
+            circularDependencies: circularDeps,
+            mostDependantFile: Object.entries(dependencies).sort(([, a], [, b]) => b.length - a.length)[0],
+        };
+    }
+    async assessCoupling(projectRoot) {
+        // Simplified coupling assessment
+        return {
+            afferentCoupling: 0, // Incoming dependencies
+            efferentCoupling: 0, // Outgoing dependencies
+            instability: 0.5,
+            abstractness: 0.3,
+        };
+    }
+    async detectCircularDependencies(projectRoot) {
+        // Simplified circular dependency detection
+        return []; // Would implement proper cycle detection
+    }
+    async generateDependencyGraphs(projectRoot) {
+        // Would generate graphviz or similar format
+        return { format: "graphviz", data: "digraph { A -> B; }" };
+    }
+    async generateDependencyRecommendations(projectRoot) {
+        return [
+            "Consider introducing interface boundaries to reduce coupling",
+            "Review circular dependencies and break them with dependency inversion",
+            "Evaluate orphan modules for potential dead code",
+        ];
+    }
+    async calculateArchitecturalScores(projectRoot, focusMetrics) {
+        return {
+            modularity: 75,
+            coupling: 65,
+            cohesion: 80,
+            testability: 70,
+            scalability: 72,
+        };
+    }
+    async identifyArchitecturalIssues(projectRoot) {
+        return [
+            {
+                severity: "medium",
+                category: "coupling",
+                description: "Some modules have high coupling",
+                recommendation: "Consider introducing facades or adapters",
+            },
+        ];
+    }
+    async recognizeArchitecturalPatterns(projectRoot) {
+        const files = await this.getProjectFiles(projectRoot);
+        const patterns = [];
+        if (files.some((f) => f.includes("controller")))
+            patterns.push("MVC Controllers");
+        if (files.some((f) => f.includes("service")))
+            patterns.push("Service Layer");
+        if (files.some((f) => f.includes("repository")))
+            patterns.push("Repository Pattern");
+        return patterns;
+    }
+    async generateArchitecturalRecommendations(projectRoot) {
+        return [
+            "Consider implementing a layered architecture",
+            "Introduce dependency injection to reduce coupling",
+            "Add comprehensive error handling and logging",
+        ];
+    }
+    async calculateOverallHealthScore(projectRoot) {
+        // Simplified health score calculation
+        return 78;
+    }
+    // Utility methods
+    async getProjectFiles(projectRoot) {
+        const files = [];
+        const traverse = (dir) => {
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const entryPath = path.join(dir, entry.name);
+                    if (this.shouldIgnorePath(entryPath))
+                        continue;
+                    if (entry.isFile()) {
+                        files.push(entryPath);
+                    }
+                    else if (entry.isDirectory()) {
+                        traverse(entryPath);
+                    }
+                }
+            }
+            catch (error) {
+                // Skip inaccessible directories
+            }
+        };
+        traverse(projectRoot);
+        return files;
+    }
+    async getProjectDirectories(projectRoot) {
+        const dirs = [];
+        const traverse = (dir) => {
+            dirs.push(dir);
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const entryPath = path.join(dir, entry.name);
+                    if (this.shouldIgnorePath(entryPath))
+                        continue;
+                    if (entry.isDirectory()) {
+                        traverse(entryPath);
+                    }
+                }
+            }
+            catch (error) {
+                // Skip inaccessible directories
+            }
+        };
+        traverse(projectRoot);
+        return dirs;
+    }
+    groupByExtension(files) {
+        const groups = {};
+        for (const file of files) {
+            const ext = path.extname(file) || "no-extension";
+            groups[ext] = (groups[ext] || 0) + 1;
+        }
+        return groups;
+    }
+    calculateMaxDepth(directories) {
+        return Math.max(...directories.map((dir) => dir.split("/").length));
+    }
+    extractImports(content) {
+        const imports = [];
+        const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const importPath = match[1];
+            if (importPath &&
+                !importPath.startsWith(".") &&
+                !importPath.startsWith("/")) {
+                imports.push(importPath);
+            }
+        }
+        return imports;
+    }
+    shouldIgnorePath(filePath) {
+        const ignorePatterns = [
+            /node_modules/,
+            /\.git/,
+            /dist/,
+            /build/,
+            /\.next/,
+            /\.nuxt/,
+            /\.cache/,
+            /\.temp/,
+            /coverage/,
+            /\.nyc_output/,
+            /logs/,
+            /\.DS_Store/,
+            /Thumbs\.db/,
+        ];
+        return ignorePatterns.some((pattern) => pattern.test(filePath));
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.log("StrRay Architect Tools MCP Server started");
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new StrRayArchitectToolsServer();
+    server.run().catch(console.error);
+}
+export default StrRayArchitectToolsServer;
+//# sourceMappingURL=architect-tools.server.js.map