trinity-method-sdk 2.0.0

package/dist/cli/types.js

@@ -0,0 +1,5 @@
+/**
+ * CLI Command Option Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli/utils/deploy-ci.d.ts

@@ -0,0 +1,22 @@
+interface CIDeploymentStats {
+    deployed: string[];
+    skipped: string[];
+    errors: Array<{
+        file?: string;
+        error?: string;
+        general?: string;
+    }>;
+}
+interface CIDeployOptions {
+    yes?: boolean;
+    force?: boolean;
+}
+/**
+ * Deploy CI/CD workflow templates based on detected Git platform
+ *
+ * @param options - Deployment options
+ * @returns Deployment results with statistics
+ */
+export declare function deployCITemplates(options?: CIDeployOptions): Promise<CIDeploymentStats>;
+export {};
+//# sourceMappingURL=deploy-ci.d.ts.map

package/dist/cli/utils/deploy-ci.js

@@ -0,0 +1,138 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { validatePath } from './validate-path.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Deploy GitLab CI template
+ * @param templatesPath - Path to templates directory
+ * @param options - Deployment options
+ * @param stats - Statistics object to update
+ */
+async function deployGitLabCI(templatesPath, options, stats) {
+    try {
+        const gitlabTemplate = path.join(templatesPath, 'gitlab-ci.yml');
+        if (!(await fs.pathExists(gitlabTemplate))) {
+            return;
+        }
+        const content = await fs.readFile(gitlabTemplate, 'utf8');
+        const gitlabCIExists = await fs.pathExists('.gitlab-ci.yml');
+        if (gitlabCIExists && !options.force) {
+            stats.skipped.push('.gitlab-ci.yml (already exists)');
+            return;
+        }
+        // Validate destination path for security
+        const destPath = validatePath('.gitlab-ci.yml');
+        await fs.writeFile(destPath, content);
+        stats.deployed.push('.gitlab-ci.yml');
+    }
+    catch (error) {
+        const { getErrorMessage } = await import('./errors.js');
+        stats.errors.push({ file: '.gitlab-ci.yml', error: getErrorMessage(error) });
+    }
+}
+/**
+ * Deploy CI/CD workflow templates based on detected Git platform
+ *
+ * @param options - Deployment options
+ * @returns Deployment results with statistics
+ */
+export async function deployCITemplates(options = {}) {
+    const stats = {
+        deployed: [],
+        skipped: [],
+        errors: [],
+    };
+    try {
+        // Detect Git platform
+        const platform = await detectGitPlatform();
+        const templatesPath = path.join(__dirname, '../../templates/ci');
+        // GitHub Actions - Deploy both CI and CD workflows
+        if (platform === 'github' || platform === 'unknown') {
+            try {
+                await fs.ensureDir('.github/workflows');
+                // Deploy CI workflow
+                const ciTemplate = path.join(templatesPath, 'ci.yml.template');
+                if (await fs.pathExists(ciTemplate)) {
+                    const content = await fs.readFile(ciTemplate, 'utf8');
+                    // Validate destination path for security
+                    const destPath = validatePath('.github/workflows/ci.yml');
+                    await fs.writeFile(destPath, content);
+                    stats.deployed.push('.github/workflows/ci.yml');
+                }
+                // Deploy CD workflow
+                const cdTemplate = path.join(templatesPath, 'cd.yml.template');
+                if (await fs.pathExists(cdTemplate)) {
+                    const content = await fs.readFile(cdTemplate, 'utf8');
+                    // Validate destination path for security
+                    const destPath = validatePath('.github/workflows/cd.yml');
+                    await fs.writeFile(destPath, content);
+                    stats.deployed.push('.github/workflows/cd.yml');
+                }
+            }
+            catch (error) {
+                const { getErrorMessage } = await import('./errors.js');
+                stats.errors.push({
+                    file: '.github/workflows/ci.yml or cd.yml',
+                    error: getErrorMessage(error),
+                });
+            }
+        }
+        // GitLab CI
+        if (platform === 'gitlab') {
+            await deployGitLabCI(templatesPath, options, stats);
+        }
+        // Generic template (always deploy to trinity/templates/ci)
+        try {
+            await fs.ensureDir('trinity/templates/ci');
+            const genericTemplate = path.join(templatesPath, 'generic-ci.yml');
+            if (await fs.pathExists(genericTemplate)) {
+                const content = await fs.readFile(genericTemplate, 'utf8');
+                // Validate destination path for security
+                const destPath = validatePath('trinity/templates/ci/generic-ci.yml');
+                await fs.writeFile(destPath, content);
+                stats.deployed.push('trinity/templates/ci/generic-ci.yml');
+            }
+        }
+        catch (error) {
+            const { getErrorMessage } = await import('./errors.js');
+            stats.errors.push({
+                file: 'trinity/templates/ci/generic-ci.yml',
+                error: getErrorMessage(error),
+            });
+        }
+        return stats;
+    }
+    catch (error) {
+        const { getErrorMessage } = await import('./errors.js');
+        stats.errors.push({ general: getErrorMessage(error) });
+        return stats;
+    }
+}
+/**
+ * Detect Git platform (GitHub, GitLab, or unknown)
+ *
+ * @returns Platform name: 'github', 'gitlab', or 'unknown'
+ */
+async function detectGitPlatform() {
+    try {
+        // Check .git/config for remote origin
+        const gitConfigPath = '.git/config';
+        if (await fs.pathExists(gitConfigPath)) {
+            const config = await fs.readFile(gitConfigPath, 'utf8');
+            if (config.includes('github.com')) {
+                return 'github';
+            }
+            if (config.includes('gitlab.com') || config.includes('gitlab')) {
+                return 'gitlab';
+            }
+        }
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+//# sourceMappingURL=deploy-ci.js.map

package/dist/cli/utils/deploy-linting.d.ts

@@ -0,0 +1,3 @@
+import { LintingTool, Stack } from '../types.js';
+export declare function deployLintingTool(tool: LintingTool, stack: Stack, templatesPath: string, variables: Record<string, string | number>): Promise<void>;
+//# sourceMappingURL=deploy-linting.d.ts.map

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

@@ -0,0 +1,136 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { processTemplate } from './template-processor.js';
+import { validatePath } from './validate-path.js';
+export async function deployLintingTool(tool, stack, templatesPath, variables) {
+    const frameworkDir = getFrameworkDirectory(stack.framework);
+    const templateDir = path.join(templatesPath, 'linting', frameworkDir);
+    switch (tool.id) {
+        case 'eslint':
+        case 'eslint-typescript': // Alias for eslint with TypeScript (backward compatibility)
+            await deployESLint(tool, stack, templateDir, variables);
+            break;
+        case 'prettier':
+            await deployPrettier(tool, templateDir, variables);
+            break;
+        case 'precommit':
+            await deployPreCommit(tool, templateDir, variables);
+            break;
+        case 'typescript-eslint':
+            await deployTypeScriptESLint(tool, stack, templateDir, variables);
+            break;
+        case 'black':
+        case 'flake8':
+        case 'isort':
+            await deployPythonTool(tool, templateDir, variables);
+            break;
+        case 'dartanalyzer':
+            await deployDartAnalyzer(tool, templateDir, variables);
+            break;
+        case 'clippy':
+        case 'rustfmt':
+            await deployRustTool(tool, templateDir, variables);
+            break;
+        default:
+            console.warn(`Unknown linting tool: ${tool.id}`);
+    }
+}
+function getFrameworkDirectory(framework) {
+    const frameworkMap = {
+        'Node.js': 'nodejs',
+        React: 'nodejs',
+        'Next.js': 'nodejs',
+        Python: 'python',
+        Flutter: 'flutter',
+        Rust: 'rust',
+    };
+    return frameworkMap[framework] || 'nodejs';
+}
+async function deployESLint(tool, stack, templateDir, variables) {
+    let templateFile;
+    if (stack.language === 'TypeScript') {
+        templateFile = '.eslintrc-typescript.json.template';
+    }
+    else if ('moduleType' in stack && stack.moduleType === 'esm') {
+        templateFile = '.eslintrc-esm.json.template';
+    }
+    else {
+        templateFile = '.eslintrc-commonjs.json.template';
+    }
+    const templatePath = path.join(templateDir, templateFile);
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    // Validate destination path for security
+    const destPath = validatePath('.eslintrc.json');
+    await fs.writeFile(destPath, processed);
+}
+async function deployPrettier(tool, templateDir, variables) {
+    const templatePath = path.join(templateDir, '.prettierrc.json.template');
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    // Validate destination path for security
+    const destPath = validatePath('.prettierrc.json');
+    await fs.writeFile(destPath, processed);
+}
+async function deployPreCommit(tool, templateDir, variables) {
+    const templatePath = path.join(templateDir, '.pre-commit-config.yaml.template');
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    // Validate destination path for security
+    const destPath = validatePath('.pre-commit-config.yaml');
+    await fs.writeFile(destPath, processed);
+}
+async function deployTypeScriptESLint(_tool, _stack, _templateDir, _variables) {
+    // Modify existing .eslintrc.json to add TypeScript support
+    const eslintPath = '.eslintrc.json';
+    if (await fs.pathExists(eslintPath)) {
+        const config = await fs.readJson(eslintPath);
+        config.extends = config.extends || [];
+        if (!config.extends.includes('plugin:@typescript-eslint/recommended')) {
+            config.extends.push('plugin:@typescript-eslint/recommended');
+        }
+        config.parser = '@typescript-eslint/parser';
+        config.plugins = config.plugins || [];
+        if (!config.plugins.includes('@typescript-eslint')) {
+            config.plugins.push('@typescript-eslint');
+        }
+        await fs.writeJson(eslintPath, config, { spaces: 2 });
+    }
+}
+async function deployPythonTool(tool, templateDir, variables) {
+    if (tool.id === 'black' || tool.id === 'isort') {
+        // Both go in pyproject.toml
+        const templatePath = path.join(templateDir, 'pyproject.toml.template');
+        const content = await fs.readFile(templatePath, 'utf8');
+        const processed = processTemplate(content, variables);
+        // Validate destination path for security
+        const destPath = validatePath('pyproject.toml');
+        await fs.writeFile(destPath, processed);
+    }
+    else if (tool.id === 'flake8') {
+        const templatePath = path.join(templateDir, '.flake8.template');
+        const content = await fs.readFile(templatePath, 'utf8');
+        const processed = processTemplate(content, variables);
+        // Validate destination path for security
+        const destPath = validatePath('.flake8');
+        await fs.writeFile(destPath, processed);
+    }
+}
+async function deployDartAnalyzer(tool, templateDir, variables) {
+    const templatePath = path.join(templateDir, 'analysis_options.yaml.template');
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    // Validate destination path for security
+    const destPath = validatePath('analysis_options.yaml');
+    await fs.writeFile(destPath, processed);
+}
+async function deployRustTool(tool, templateDir, variables) {
+    const filename = tool.id === 'clippy' ? 'clippy.toml' : 'rustfmt.toml';
+    const templatePath = path.join(templateDir, `${filename}.template`);
+    const content = await fs.readFile(templatePath, 'utf8');
+    const processed = processTemplate(content, variables);
+    // Validate destination path for security
+    const destPath = validatePath(filename);
+    await fs.writeFile(destPath, processed);
+}
+//# sourceMappingURL=deploy-linting.js.map

package/dist/cli/utils/detect-stack.d.ts

@@ -0,0 +1,3 @@
+import { Stack } from '../types.js';
+export declare function detectStack(targetDir?: string): Promise<Stack>;
+//# sourceMappingURL=detect-stack.d.ts.map

package/dist/cli/utils/detect-stack.js

@@ -0,0 +1,270 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+// Common source directory names
+const COMMON_SOURCE_DIRS = [
+    'src',
+    'lib',
+    'app',
+    'backend',
+    'frontend',
+    'server',
+    'client',
+    'database',
+    'packages',
+    'apps',
+];
+// Nested directory patterns (2-level and 3-level)
+const NESTED_PATTERNS = [
+    // 2-level patterns - backend variations
+    ['backend', 'src'],
+    ['backend', 'lib'],
+    ['backend', 'app'],
+    // 2-level patterns - frontend variations
+    ['frontend', 'src'],
+    ['frontend', 'lib'],
+    ['frontend', 'app'],
+    // 2-level patterns - server/client variations
+    ['server', 'src'],
+    ['server', 'lib'],
+    ['server', 'app'],
+    ['client', 'src'],
+    ['client', 'lib'],
+    ['client', 'app'],
+    // 2-level patterns - src nested
+    ['src', 'backend'],
+    ['src', 'frontend'],
+    ['src', 'database'],
+    ['src', 'server'],
+    ['src', 'client'],
+    // 3-level patterns - src nested deeply
+    ['src', 'backend', 'src'],
+    ['src', 'backend', 'lib'],
+    ['src', 'backend', 'app'],
+    ['src', 'frontend', 'src'],
+    ['src', 'frontend', 'lib'],
+    ['src', 'frontend', 'app'],
+    ['src', 'database', 'src'],
+    ['src', 'database', 'lib'],
+    // 3-level patterns - frontend/backend with app
+    ['frontend', 'app', 'lib'],
+    ['frontend', 'app', 'src'],
+    ['backend', 'app', 'lib'],
+    ['backend', 'app', 'src'],
+    ['server', 'app', 'lib'],
+    ['server', 'app', 'src'],
+    ['client', 'app', 'lib'],
+    ['client', 'app', 'src'],
+];
+/**
+ * Detect all source directories in the project (monorepo support)
+ */
+async function detectSourceDirectories(targetDir) {
+    const foundDirs = [];
+    // Check top-level directories
+    for (const dir of COMMON_SOURCE_DIRS) {
+        const dirPath = path.join(targetDir, dir);
+        if (await exists(dirPath)) {
+            foundDirs.push(dir);
+        }
+    }
+    // Check 2-level nested patterns
+    for (const pattern of NESTED_PATTERNS) {
+        if (pattern.length === 2) {
+            const [parent, child] = pattern;
+            const fullPath = path.join(targetDir, parent, child);
+            if (await exists(fullPath)) {
+                const relativePath = `${parent}/${child}`;
+                if (!foundDirs.includes(relativePath)) {
+                    foundDirs.push(relativePath);
+                }
+            }
+        }
+    }
+    // Check 3-level nested patterns (also captures intermediate directories)
+    for (const pattern of NESTED_PATTERNS) {
+        if (pattern.length === 3) {
+            const [level1, level2, level3] = pattern;
+            const fullPath = path.join(targetDir, level1, level2, level3);
+            if (await exists(fullPath)) {
+                // Add the 3-level path
+                const deepPath = `${level1}/${level2}/${level3}`;
+                if (!foundDirs.includes(deepPath)) {
+                    foundDirs.push(deepPath);
+                }
+                // Also add intermediate 2-level path
+                const intermediatePath = `${level1}/${level2}`;
+                if (!foundDirs.includes(intermediatePath)) {
+                    foundDirs.push(intermediatePath);
+                }
+            }
+        }
+    }
+    return foundDirs;
+}
+/**
+ * Detect Flutter project
+ */
+async function detectFlutter(targetDir) {
+    if (await exists(path.join(targetDir, 'pubspec.yaml'))) {
+        return {
+            language: 'Dart',
+            framework: 'Flutter',
+            sourceDir: 'lib',
+        };
+    }
+    return null;
+}
+/**
+ * Detect Rust project
+ */
+async function detectRust(targetDir) {
+    if (await exists(path.join(targetDir, 'Cargo.toml'))) {
+        return {
+            language: 'Rust',
+            framework: 'Generic',
+            sourceDir: 'src',
+        };
+    }
+    return null;
+}
+/**
+ * Detect Go project
+ */
+async function detectGo(targetDir) {
+    if (await exists(path.join(targetDir, 'go.mod'))) {
+        return {
+            language: 'Go',
+            framework: 'Generic',
+            sourceDir: '.',
+        };
+    }
+    return null;
+}
+/**
+ * Detect Node.js/JavaScript framework
+ */
+async function detectNodeFramework(pkg) {
+    const deps = pkg.dependencies;
+    if (deps?.next)
+        return 'Next.js';
+    if (deps?.react)
+        return 'React';
+    if (deps?.vue)
+        return 'Vue';
+    if (deps?.['@angular/core'])
+        return 'Angular';
+    if (deps?.express)
+        return 'Express';
+    return 'Node.js';
+}
+/**
+ * Detect package manager
+ */
+async function detectPackageManager(targetDir) {
+    if (await exists(path.join(targetDir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (await exists(path.join(targetDir, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+/**
+ * Detect Node.js project
+ */
+async function detectNodeJs(targetDir) {
+    if (!(await exists(path.join(targetDir, 'package.json')))) {
+        return null;
+    }
+    try {
+        const pkgPath = path.join(targetDir, 'package.json');
+        const pkgContent = await fs.readFile(pkgPath, 'utf8');
+        const pkg = JSON.parse(pkgContent);
+        const framework = await detectNodeFramework(pkg);
+        const packageManager = await detectPackageManager(targetDir);
+        return {
+            language: 'JavaScript/TypeScript',
+            framework,
+            sourceDir: framework === 'Angular' ? 'src/app' : 'src',
+            packageManager,
+        };
+    }
+    catch (parseError) {
+        const { displayError, getErrorMessage } = await import('../utils/errors.js');
+        displayError(`Error parsing package.json: ${getErrorMessage(parseError)}`);
+        return null;
+    }
+}
+/**
+ * Detect Python project
+ */
+async function detectPython(targetDir) {
+    const hasPythonFiles = (await exists(path.join(targetDir, 'requirements.txt'))) ||
+        (await exists(path.join(targetDir, 'setup.py'))) ||
+        (await exists(path.join(targetDir, 'pyproject.toml')));
+    if (!hasPythonFiles) {
+        return null;
+    }
+    let framework = 'Generic';
+    // Check for Flask
+    if (await exists(path.join(targetDir, 'requirements.txt'))) {
+        const reqContent = await fs.readFile(path.join(targetDir, 'requirements.txt'), 'utf8');
+        if (reqContent.toLowerCase().includes('flask')) {
+            framework = 'Flask';
+        }
+    }
+    return {
+        language: 'Python',
+        framework,
+        sourceDir: 'app',
+    };
+}
+/**
+ * Finalize source directories
+ */
+function finalizeSourceDirs(result) {
+    if (result.sourceDirs.length === 0) {
+        result.sourceDirs = [result.sourceDir];
+    }
+    else if (!result.sourceDirs.includes(result.sourceDir)) {
+        result.sourceDir = result.sourceDirs[0];
+    }
+}
+export async function detectStack(targetDir = process.cwd()) {
+    const result = {
+        language: 'Unknown',
+        framework: 'Generic',
+        sourceDir: 'src',
+        sourceDirs: [],
+        packageManager: 'npm',
+    };
+    try {
+        // Detector array pattern - order matters!
+        // Check Flutter FIRST to avoid false positives when Trinity SDK creates package.json
+        const detectors = [detectFlutter, detectRust, detectGo, detectNodeJs, detectPython];
+        for (const detector of detectors) {
+            const detected = await detector(targetDir);
+            if (detected) {
+                Object.assign(result, detected);
+                break;
+            }
+        }
+    }
+    catch (error) {
+        const { displayWarning, getErrorMessage } = await import('../utils/errors.js');
+        displayWarning(`Error detecting stack: ${getErrorMessage(error)}`);
+    }
+    // Detect all source directories (monorepo support)
+    result.sourceDirs = await detectSourceDirectories(targetDir);
+    // Finalize source directories
+    finalizeSourceDirs(result);
+    return result;
+}
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=detect-stack.js.map

package/dist/cli/utils/error-classes.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Custom error classes for Trinity CLI
+ * Provides domain-specific error types with codes and context
+ * @module cli/utils/error-classes
+ */
+/**
+ * Base error class for Trinity CLI
+ * All custom errors extend this class
+ */
+export declare class TrinityCLIError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly context?: Record<string, unknown>;
+    /**
+     * Create a Trinity CLI error
+     * @param message - Human-readable error message
+     * @param code - Error code for categorization (e.g., 'DEPLOYMENT_ERROR')
+     * @param exitCode - Process exit code (default: 1)
+     * @param context - Additional context for debugging
+     */
+    constructor(message: string, code: string, exitCode?: number, context?: Record<string, unknown>);
+    /**
+     * Format error for user display
+     * @returns Formatted error message with code
+     */
+    format(): string;
+}
+/**
+ * User input validation errors
+ * Used when user provides invalid input or options
+ */
+export declare class ValidationError extends TrinityCLIError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Filesystem operation errors
+ * Used when file/directory operations fail
+ */
+export declare class FilesystemError extends TrinityCLIError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Deployment errors
+ * Used when Trinity deployment fails
+ */
+export declare class DeploymentError extends TrinityCLIError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Update errors
+ * Used when Trinity update fails
+ */
+export declare class UpdateError extends TrinityCLIError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Configuration errors
+ * Used when configuration is invalid or missing
+ */
+export declare class ConfigurationError extends TrinityCLIError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+//# sourceMappingURL=error-classes.d.ts.map