trinity-method-sdk 2.0.0

package/dist/cli/utils/linting-tools.js

@@ -0,0 +1,206 @@
+export const lintingTools = {
+    'Node.js': [
+        {
+            id: 'eslint',
+            name: 'ESLint',
+            description: 'JavaScript/TypeScript linter',
+            file: '.eslintrc.json',
+            recommended: true,
+            dependencies: ['eslint@^8.50.0'],
+            scripts: {
+                lint: 'eslint .',
+                'lint:fix': 'eslint . --fix',
+            },
+        },
+        {
+            id: 'prettier',
+            name: 'Prettier',
+            description: 'Code formatter',
+            file: '.prettierrc.json',
+            recommended: true,
+            dependencies: ['prettier@^3.0.0'],
+            scripts: {
+                format: 'prettier --write "**/*.{js,jsx,ts,tsx,json,md}"',
+                'format:check': 'prettier --check "**/*.{js,jsx,ts,tsx,json,md}"',
+            },
+        },
+        {
+            id: 'precommit',
+            name: 'Pre-commit hooks',
+            description: 'Git hooks for code quality',
+            file: '.pre-commit-config.yaml',
+            recommended: true,
+            dependencies: [],
+        },
+        {
+            id: 'typescript-eslint',
+            name: 'TypeScript ESLint',
+            description: 'TypeScript-specific linting',
+            file: 'extends typescript in .eslintrc.json',
+            recommended: false, // Only if TypeScript detected
+            dependencies: ['@typescript-eslint/parser@^6.7.0', '@typescript-eslint/eslint-plugin@^6.7.0'],
+        },
+    ],
+    React: [
+        {
+            id: 'eslint',
+            name: 'ESLint',
+            description: 'JavaScript/TypeScript linter',
+            file: '.eslintrc.json',
+            recommended: true,
+            dependencies: ['eslint@^8.50.0', 'eslint-plugin-react@^7.33.0'],
+            scripts: {
+                lint: 'eslint .',
+                'lint:fix': 'eslint . --fix',
+            },
+        },
+        {
+            id: 'prettier',
+            name: 'Prettier',
+            description: 'Code formatter',
+            file: '.prettierrc.json',
+            recommended: true,
+            dependencies: ['prettier@^3.0.0'],
+            scripts: {
+                format: 'prettier --write "**/*.{js,jsx,ts,tsx,json,md}"',
+                'format:check': 'prettier --check "**/*.{js,jsx,ts,tsx,json,md}"',
+            },
+        },
+        {
+            id: 'precommit',
+            name: 'Pre-commit hooks',
+            description: 'Git hooks for code quality',
+            file: '.pre-commit-config.yaml',
+            recommended: true,
+            dependencies: [],
+        },
+        {
+            id: 'typescript-eslint',
+            name: 'TypeScript ESLint',
+            description: 'TypeScript-specific linting',
+            file: 'extends typescript in .eslintrc.json',
+            recommended: false,
+            dependencies: ['@typescript-eslint/parser@^6.7.0', '@typescript-eslint/eslint-plugin@^6.7.0'],
+        },
+    ],
+    Python: [
+        {
+            id: 'black',
+            name: 'Black',
+            description: 'Python code formatter',
+            file: 'pyproject.toml',
+            recommended: true,
+            dependencies: ['black>=23.0.0'],
+        },
+        {
+            id: 'flake8',
+            name: 'Flake8',
+            description: 'Python linter',
+            file: '.flake8',
+            recommended: true,
+            dependencies: ['flake8>=6.0.0'],
+        },
+        {
+            id: 'isort',
+            name: 'isort',
+            description: 'Import sorter',
+            file: 'pyproject.toml',
+            recommended: true,
+            dependencies: ['isort>=5.12.0'],
+        },
+        {
+            id: 'precommit',
+            name: 'Pre-commit hooks',
+            description: 'Git hooks for code quality',
+            file: '.pre-commit-config.yaml',
+            recommended: true,
+            dependencies: ['pre-commit>=3.3.0'],
+        },
+    ],
+    Flutter: [
+        {
+            id: 'dartanalyzer',
+            name: 'Dart Analyzer',
+            description: 'Dart/Flutter linter',
+            file: 'analysis_options.yaml',
+            recommended: true,
+            dependencies: [], // Built into Dart SDK
+        },
+        {
+            id: 'precommit',
+            name: 'Pre-commit hooks',
+            description: 'Git hooks for code quality',
+            file: '.pre-commit-config.yaml',
+            recommended: true,
+            dependencies: [],
+        },
+    ],
+    Rust: [
+        {
+            id: 'clippy',
+            name: 'Clippy',
+            description: 'Rust linter',
+            file: 'clippy.toml',
+            recommended: true,
+            dependencies: [], // Built into Rust toolchain
+        },
+        {
+            id: 'rustfmt',
+            name: 'Rustfmt',
+            description: 'Rust formatter',
+            file: 'rustfmt.toml',
+            recommended: true,
+            dependencies: [], // Built into Rust toolchain
+        },
+        {
+            id: 'precommit',
+            name: 'Pre-commit hooks',
+            description: 'Git hooks for code quality',
+            file: '.pre-commit-config.yaml',
+            recommended: true,
+            dependencies: [],
+        },
+    ],
+};
+export function getToolsForFramework(framework, language) {
+    // Special handling for TypeScript
+    const tools = lintingTools[framework] || lintingTools['Node.js'] || [];
+    if (language === 'TypeScript') {
+        return tools.map((tool) => {
+            if (tool.requiresTypeScript) {
+                return { ...tool, recommended: true };
+            }
+            return tool;
+        });
+    }
+    return tools.filter((tool) => !tool.requiresTypeScript);
+}
+export function getRecommendedTools(framework, language) {
+    const tools = getToolsForFramework(framework, language);
+    return tools.filter((tool) => tool.recommended);
+}
+export function getDependenciesForTools(selectedTools) {
+    return selectedTools.flatMap((tool) => tool.dependencies || []);
+}
+export function getScriptsForTools(selectedTools) {
+    const scripts = {};
+    selectedTools.forEach((tool) => {
+        if (tool.scripts) {
+            Object.assign(scripts, tool.scripts);
+        }
+    });
+    return scripts;
+}
+export function getPostInstallInstructions(selectedTools, _framework) {
+    const instructions = [];
+    selectedTools.forEach((tool) => {
+        if (tool.postInstall) {
+            instructions.push({
+                command: tool.postInstall,
+                description: `Setup ${tool.name}`,
+            });
+        }
+    });
+    return instructions;
+}
+//# sourceMappingURL=linting-tools.js.map

package/dist/cli/utils/metrics/code-quality.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Code Quality Metrics Collection
+ * Counts TODOs, FIXMEs, console statements, and commented code blocks
+ * @module cli/utils/metrics/code-quality
+ */
+/**
+ * Count occurrences of a pattern in source files
+ * @param dir - Directory to search
+ * @param pattern - Pattern to match
+ * @returns Count of matches
+ */
+export declare function countPattern(dir: string, pattern: RegExp): Promise<number>;
+/**
+ * Count commented code blocks (heuristic: 3+ consecutive comment lines)
+ * @param dir - Directory to search
+ * @returns Estimated count of commented code blocks
+ */
+export declare function countCommentedCode(dir: string): Promise<number>;
+/**
+ * Collect code quality metrics
+ * @param sourceDir - Source directory to analyze
+ * @returns Code quality metrics
+ */
+export declare function collectCodeQualityMetrics(sourceDir: string): Promise<{
+    todoCount: number;
+    todoComments: number;
+    fixmeComments: number;
+    hackComments: number;
+    consoleStatements: number;
+    commentedCodeBlocks: number;
+}>;
+//# sourceMappingURL=code-quality.d.ts.map

package/dist/cli/utils/metrics/code-quality.js

@@ -0,0 +1,122 @@
+/**
+ * Code Quality Metrics Collection
+ * Counts TODOs, FIXMEs, console statements, and commented code blocks
+ * @module cli/utils/metrics/code-quality
+ */
+import fs from 'fs-extra';
+import { globSync } from 'glob';
+/**
+ * Count occurrences of a pattern in source files
+ * @param dir - Directory to search
+ * @param pattern - Pattern to match
+ * @returns Count of matches
+ */
+export async function countPattern(dir, pattern) {
+    if (!(await fs.pathExists(dir))) {
+        return 0;
+    }
+    try {
+        // Get all source files
+        const files = globSync(`${dir}/**/*.{js,jsx,ts,tsx,dart,py,rs}`, {
+            ignore: [
+                '**/node_modules/**',
+                '**/build/**',
+                '**/.dart_tool/**',
+                '**/dist/**',
+                '**/__pycache__/**',
+            ],
+        });
+        let count = 0;
+        for (const file of files) {
+            const content = await fs.readFile(file, 'utf8');
+            const matches = content.match(pattern);
+            if (matches) {
+                count += matches.length;
+            }
+        }
+        return count;
+    }
+    catch (error) {
+        const { displayWarning, getErrorMessage } = await import('../errors.js');
+        displayWarning(`Error counting pattern: ${getErrorMessage(error)}`);
+        return 0;
+    }
+}
+/**
+ * Count consecutive comments in a single file
+ * @param file - File path to analyze
+ * @returns Number of commented code blocks in the file
+ */
+async function countCommentsInFile(file) {
+    const content = await fs.readFile(file, 'utf8');
+    const lines = content.split('\n');
+    let blockCount = 0;
+    let consecutiveComments = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const isComment = trimmed.startsWith('//') || trimmed.startsWith('#');
+        if (isComment) {
+            consecutiveComments++;
+            if (consecutiveComments === 3) {
+                blockCount++;
+            }
+        }
+        else {
+            consecutiveComments = 0;
+        }
+    }
+    return blockCount;
+}
+/**
+ * Count commented code blocks (heuristic: 3+ consecutive comment lines)
+ * @param dir - Directory to search
+ * @returns Estimated count of commented code blocks
+ */
+export async function countCommentedCode(dir) {
+    if (!(await fs.pathExists(dir))) {
+        return 0;
+    }
+    try {
+        const files = globSync(`${dir}/**/*.{js,jsx,ts,tsx,dart,py,rs}`, {
+            ignore: [
+                '**/node_modules/**',
+                '**/build/**',
+                '**/.dart_tool/**',
+                '**/dist/**',
+                '**/__pycache__/**',
+            ],
+        });
+        let blockCount = 0;
+        for (const file of files) {
+            blockCount += await countCommentsInFile(file);
+        }
+        return blockCount;
+    }
+    catch (error) {
+        const { displayWarning, getErrorMessage } = await import('../errors.js');
+        displayWarning(`Error counting commented code: ${getErrorMessage(error)}`);
+        return 0;
+    }
+}
+/**
+ * Collect code quality metrics
+ * @param sourceDir - Source directory to analyze
+ * @returns Code quality metrics
+ */
+export async function collectCodeQualityMetrics(sourceDir) {
+    const todoComments = await countPattern(sourceDir, /\/\/\s*TODO|#\s*TODO/gi);
+    const fixmeComments = await countPattern(sourceDir, /\/\/\s*FIXME|#\s*FIXME/gi);
+    const hackComments = await countPattern(sourceDir, /\/\/\s*HACK|#\s*HACK/gi);
+    const todoCount = todoComments + fixmeComments + hackComments;
+    const consoleStatements = await countPattern(sourceDir, /console\.(log|warn|error|debug|info)/gi);
+    const commentedCodeBlocks = await countCommentedCode(sourceDir);
+    return {
+        todoCount,
+        todoComments,
+        fixmeComments,
+        hackComments,
+        consoleStatements,
+        commentedCodeBlocks,
+    };
+}
+//# sourceMappingURL=code-quality.js.map

package/dist/cli/utils/metrics/dependency-parser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Dependency Parsing Module
+ * Parses dependencies from framework-specific files (package.json, pubspec.yaml, etc.)
+ * @module cli/utils/metrics/dependency-parser
+ */
+/**
+ * Dependency metrics
+ */
+export interface DependencyMetrics {
+    dependencies: Record<string, string>;
+    dependencyCount: number;
+    devDependencies: Record<string, string>;
+    devDependencyCount: number;
+}
+/**
+ * Parse dependencies from framework-specific files
+ * @param framework - Framework name
+ * @returns Dependencies and counts
+ */
+export declare function parseDependencies(framework: string): Promise<DependencyMetrics>;
+//# sourceMappingURL=dependency-parser.d.ts.map

package/dist/cli/utils/metrics/dependency-parser.js

@@ -0,0 +1,153 @@
+/**
+ * Dependency Parsing Module
+ * Parses dependencies from framework-specific files (package.json, pubspec.yaml, etc.)
+ * @module cli/utils/metrics/dependency-parser
+ */
+import fs from 'fs-extra';
+/**
+ * Parse package.json dependencies
+ */
+async function parsePackageJson() {
+    if (!(await fs.pathExists('package.json'))) {
+        return {};
+    }
+    const pkg = await fs.readJson('package.json');
+    const dependencies = pkg.dependencies || {};
+    const devDependencies = pkg.devDependencies || {};
+    return {
+        dependencies,
+        devDependencies,
+        dependencyCount: Object.keys(dependencies).length,
+        devDependencyCount: Object.keys(devDependencies).length,
+    };
+}
+/**
+ * Parse pubspec.yaml dependencies (Flutter)
+ */
+async function parsePubspecYaml() {
+    if (!(await fs.pathExists('pubspec.yaml'))) {
+        return {};
+    }
+    const yaml = await fs.readFile('pubspec.yaml', 'utf8');
+    const dependencies = {};
+    const devDependencies = {};
+    const depMatch = yaml.match(/dependencies:\s*\n((?: {2}[^\s].*\n(?: {4}.*\n)*)*)/);
+    const devDepMatch = yaml.match(/dev_dependencies:\s*\n((?: {2}[^\s].*\n(?: {4}.*\n)*)*)/);
+    if (depMatch) {
+        const deps = depMatch[1]
+            .split('\n')
+            .filter((line) => line.match(/^ {2}[^\s]/) && line.trim().length > 0);
+        deps.forEach((dep) => {
+            const [name] = dep.trim().split(':');
+            dependencies[name] = 'latest';
+        });
+    }
+    if (devDepMatch) {
+        const devDeps = devDepMatch[1]
+            .split('\n')
+            .filter((line) => line.match(/^ {2}[^\s]/) && line.trim().length > 0);
+        devDeps.forEach((dep) => {
+            const [name] = dep.trim().split(':');
+            devDependencies[name] = 'latest';
+        });
+    }
+    return {
+        dependencies,
+        devDependencies,
+        dependencyCount: Object.keys(dependencies).length,
+        devDependencyCount: Object.keys(devDependencies).length,
+    };
+}
+/**
+ * Parse requirements.txt dependencies (Python)
+ */
+async function parseRequirementsTxt() {
+    if (!(await fs.pathExists('requirements.txt'))) {
+        return {};
+    }
+    const reqs = await fs.readFile('requirements.txt', 'utf8');
+    const deps = reqs
+        .split('\n')
+        .filter((line) => line.trim().length > 0 && !line.startsWith('#'));
+    const dependencies = {};
+    deps.forEach((dep) => {
+        const [name] = dep.split(/[=<>]/);
+        dependencies[name.trim()] = 'latest';
+    });
+    return {
+        dependencies,
+        dependencyCount: deps.length,
+        devDependencies: {},
+        devDependencyCount: 0,
+    };
+}
+/**
+ * Parse Cargo.toml dependencies (Rust)
+ */
+async function parseCargoToml() {
+    if (!(await fs.pathExists('Cargo.toml'))) {
+        return {};
+    }
+    const toml = await fs.readFile('Cargo.toml', 'utf8');
+    const dependencies = {};
+    const devDependencies = {};
+    const depMatch = toml.match(/\[dependencies\]\s*\n((?:\w+\s*[={].*(?:\n|$))*)/);
+    const devDepMatch = toml.match(/\[dev-dependencies\]\s*\n((?:\w+\s*[={].*(?:\n|$))*)/);
+    if (depMatch) {
+        const deps = depMatch[1].split('\n').filter((line) => line.trim().length > 0);
+        deps.forEach((dep) => {
+            const [name] = dep.trim().split(/\s*[={]/);
+            dependencies[name] = 'latest';
+        });
+    }
+    if (devDepMatch) {
+        const devDeps = devDepMatch[1].split('\n').filter((line) => line.trim().length > 0);
+        devDeps.forEach((dep) => {
+            const [name] = dep.trim().split(/\s*[={]/);
+            devDependencies[name] = 'latest';
+        });
+    }
+    return {
+        dependencies,
+        devDependencies,
+        dependencyCount: Object.keys(dependencies).length,
+        devDependencyCount: Object.keys(devDependencies).length,
+    };
+}
+/**
+ * Parser map - maps frameworks to their dependency parsers
+ */
+const DEPENDENCY_PARSERS = {
+    'Node.js': parsePackageJson,
+    React: parsePackageJson,
+    'Next.js': parsePackageJson,
+    Flutter: parsePubspecYaml,
+    Python: parseRequirementsTxt,
+    Rust: parseCargoToml,
+};
+/**
+ * Parse dependencies from framework-specific files
+ * @param framework - Framework name
+ * @returns Dependencies and counts
+ */
+export async function parseDependencies(framework) {
+    const defaultResult = {
+        dependencies: {},
+        dependencyCount: 0,
+        devDependencies: {},
+        devDependencyCount: 0,
+    };
+    try {
+        const parser = DEPENDENCY_PARSERS[framework];
+        if (parser) {
+            const parsed = await parser();
+            return { ...defaultResult, ...parsed };
+        }
+    }
+    catch (error) {
+        const { displayWarning, getErrorMessage } = await import('../errors.js');
+        displayWarning(`Error parsing dependencies: ${getErrorMessage(error)}`);
+    }
+    return defaultResult;
+}
+//# sourceMappingURL=dependency-parser.js.map

package/dist/cli/utils/metrics/file-complexity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * File Complexity Metrics Collection
+ * Analyzes file counts, line counts, and identifies large files
+ * @module cli/utils/metrics/file-complexity
+ */
+/**
+ * File complexity metrics
+ */
+export interface FileComplexityMetrics {
+    totalFiles: number;
+    filesOver500: number;
+    filesOver1000: number;
+    filesOver3000: number;
+    avgFileLength: number;
+    largestFiles: Array<{
+        file: string;
+        lines: number;
+    }>;
+}
+/**
+ * Analyze file complexity metrics
+ * @param dir - Directory to analyze
+ * @returns File complexity metrics
+ */
+export declare function analyzeFileComplexity(dir: string): Promise<FileComplexityMetrics>;
+//# sourceMappingURL=file-complexity.d.ts.map

package/dist/cli/utils/metrics/file-complexity.js

@@ -0,0 +1,77 @@
+/**
+ * File Complexity Metrics Collection
+ * Analyzes file counts, line counts, and identifies large files
+ * @module cli/utils/metrics/file-complexity
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { globSync } from 'glob';
+/**
+ * Analyze file complexity metrics
+ * @param dir - Directory to analyze
+ * @returns File complexity metrics
+ */
+export async function analyzeFileComplexity(dir) {
+    if (!(await fs.pathExists(dir))) {
+        return {
+            totalFiles: 0,
+            filesOver500: 0,
+            filesOver1000: 0,
+            filesOver3000: 0,
+            avgFileLength: 0,
+            largestFiles: [],
+        };
+    }
+    try {
+        const files = globSync(`${dir}/**/*.{js,jsx,ts,tsx,dart,py,rs}`, {
+            ignore: [
+                '**/node_modules/**',
+                '**/build/**',
+                '**/.dart_tool/**',
+                '**/dist/**',
+                '**/__pycache__/**',
+            ],
+        });
+        const fileSizes = [];
+        let filesOver500 = 0;
+        let filesOver1000 = 0;
+        let filesOver3000 = 0;
+        let totalLines = 0;
+        for (const file of files) {
+            const content = await fs.readFile(file, 'utf8');
+            const lineCount = content.split('\n').length;
+            totalLines += lineCount;
+            fileSizes.push({ file: path.relative(dir, file), lines: lineCount });
+            if (lineCount > 500)
+                filesOver500++;
+            if (lineCount > 1000)
+                filesOver1000++;
+            if (lineCount > 3000)
+                filesOver3000++;
+        }
+        // Sort by size and get top 10
+        fileSizes.sort((a, b) => b.lines - a.lines);
+        const largestFiles = fileSizes.slice(0, 10);
+        return {
+            totalFiles: files.length,
+            filesOver500,
+            filesOver1000,
+            filesOver3000,
+            avgFileLength: files.length > 0 ? Math.round(totalLines / files.length) : 0,
+            largestFiles,
+        };
+    }
+    catch (error) {
+        const { displayWarning, getErrorMessage } = await import('../errors.js');
+        displayWarning(`Error analyzing file complexity: ${getErrorMessage(error)}`);
+        return {
+            totalFiles: 0,
+            filesOver500: 0,
+            filesOver1000: 0,
+            filesOver3000: 0,
+            avgFileLength: 0,
+            largestFiles: [],
+        };
+    }
+}
+//# sourceMappingURL=file-complexity.js.map

package/dist/cli/utils/metrics/framework-detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Framework Detection Module
+ * Detects framework versions and package managers
+ * @module cli/utils/metrics/framework-detector
+ */
+/**
+ * Detect framework version
+ * @param framework - Framework name
+ * @returns Version string
+ */
+export declare function detectFrameworkVersion(framework: string): Promise<string>;
+/**
+ * Detect package manager
+ * @returns Package manager name
+ */
+export declare function detectPackageManager(): Promise<string>;
+//# sourceMappingURL=framework-detector.d.ts.map