moflo 4.8.19 → 4.8.20

package/src/@claude-flow/shared/dist/hooks/safety/file-organization.js

@@ -0,0 +1,328 @@
+/**
+ * V3 File Organization Hook
+ *
+ * TypeScript conversion of V2 file-hook.sh.
+ * Enforces file organization, blocks writes to root folder,
+ * suggests proper directories, and recommends formatters.
+ *
+ * @module v3/shared/hooks/safety/file-organization
+ */
+import * as path from 'path';
+import { HookEvent, HookPriority, } from '../types.js';
+/**
+ * File type mapping to directories
+ */
+const FILE_TYPE_DIRECTORIES = [
+    // Test files (MUST come before source files - more specific patterns first)
+    { pattern: /\.test\.(ts|tsx|js|jsx)$/, directories: ['tests/', '__tests__/', 'test/'], type: 'test file', blockRoot: true },
+    { pattern: /\.spec\.(ts|tsx|js|jsx)$/, directories: ['tests/', '__tests__/', 'test/', 'spec/'], type: 'spec file', blockRoot: true },
+    { pattern: /_test\.go$/, directories: ['tests/', 'test/'], type: 'Go test file', blockRoot: true },
+    { pattern: /test_.*\.py$/, directories: ['tests/', 'test/'], type: 'Python test file', blockRoot: true },
+    { pattern: /.*_test\.py$/, directories: ['tests/', 'test/'], type: 'Python test file', blockRoot: true },
+    // Source files
+    { pattern: /\.(ts|tsx)$/, directories: ['src/', 'lib/'], type: 'TypeScript source', blockRoot: true },
+    { pattern: /\.(js|jsx|mjs|cjs)$/, directories: ['src/', 'lib/', 'dist/'], type: 'JavaScript source', blockRoot: true },
+    { pattern: /\.py$/, directories: ['src/', 'lib/', 'app/'], type: 'Python source', blockRoot: true },
+    { pattern: /\.go$/, directories: ['cmd/', 'pkg/', 'internal/'], type: 'Go source', blockRoot: true },
+    { pattern: /\.rs$/, directories: ['src/'], type: 'Rust source', blockRoot: true },
+    { pattern: /\.java$/, directories: ['src/main/java/', 'src/'], type: 'Java source', blockRoot: true },
+    { pattern: /\.rb$/, directories: ['lib/', 'app/'], type: 'Ruby source', blockRoot: true },
+    { pattern: /\.php$/, directories: ['src/', 'app/'], type: 'PHP source', blockRoot: true },
+    { pattern: /\.cs$/, directories: ['src/'], type: 'C# source', blockRoot: true },
+    { pattern: /\.cpp?$/, directories: ['src/'], type: 'C/C++ source', blockRoot: true },
+    { pattern: /\.swift$/, directories: ['Sources/'], type: 'Swift source', blockRoot: true },
+    { pattern: /\.kt$/, directories: ['src/main/kotlin/', 'src/'], type: 'Kotlin source', blockRoot: true },
+    // Config files (usually allowed at root)
+    { pattern: /\.(json|yaml|yml|toml)$/, directories: ['config/', './', 'configs/'], type: 'config file', blockRoot: false },
+    { pattern: /\.(env|env\.[a-z]+)$/, directories: ['./'], type: 'environment file', blockRoot: false },
+    // Documentation
+    { pattern: /\.md$/, directories: ['docs/', './'], type: 'Markdown documentation', blockRoot: false },
+    { pattern: /\.rst$/, directories: ['docs/'], type: 'reStructuredText documentation', blockRoot: true },
+    { pattern: /\.adoc$/, directories: ['docs/'], type: 'AsciiDoc documentation', blockRoot: true },
+    // Assets
+    { pattern: /\.(css|scss|sass|less)$/, directories: ['styles/', 'src/styles/', 'assets/css/'], type: 'stylesheet', blockRoot: true },
+    { pattern: /\.(png|jpg|jpeg|gif|svg|ico)$/, directories: ['assets/', 'public/', 'images/', 'static/'], type: 'image', blockRoot: true },
+    { pattern: /\.(woff2?|ttf|otf|eot)$/, directories: ['assets/fonts/', 'fonts/', 'public/fonts/'], type: 'font', blockRoot: true },
+    // Scripts
+    { pattern: /\.sh$/, directories: ['scripts/', 'bin/'], type: 'shell script', blockRoot: true },
+    { pattern: /\.ps1$/, directories: ['scripts/', 'bin/'], type: 'PowerShell script', blockRoot: true },
+    // Data
+    { pattern: /\.sql$/, directories: ['migrations/', 'db/', 'database/'], type: 'SQL file', blockRoot: true },
+    { pattern: /\.csv$/, directories: ['data/', 'fixtures/', 'test/fixtures/'], type: 'CSV data', blockRoot: true },
+];
+/**
+ * Formatter recommendations by file extension
+ */
+const FORMATTERS = {
+    '.ts': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.tsx': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.js': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.jsx': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.json': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.md': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.yaml': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.yml': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.py': { name: 'Black', command: 'black', configFile: 'pyproject.toml' },
+    '.go': { name: 'gofmt', command: 'gofmt -w', configFile: undefined },
+    '.rs': { name: 'rustfmt', command: 'rustfmt', configFile: 'rustfmt.toml' },
+    '.java': { name: 'google-java-format', command: 'google-java-format -i', configFile: undefined },
+    '.rb': { name: 'RuboCop', command: 'rubocop -a', configFile: '.rubocop.yml' },
+    '.php': { name: 'PHP-CS-Fixer', command: 'php-cs-fixer fix', configFile: '.php-cs-fixer.php' },
+    '.cs': { name: 'dotnet-format', command: 'dotnet format', configFile: '.editorconfig' },
+    '.swift': { name: 'swift-format', command: 'swift-format -i', configFile: '.swift-format' },
+    '.kt': { name: 'ktlint', command: 'ktlint -F', configFile: '.editorconfig' },
+    '.css': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.scss': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+    '.html': { name: 'Prettier', command: 'prettier --write', configFile: '.prettierrc' },
+};
+/**
+ * Linter recommendations by file extension
+ */
+const LINTERS = {
+    '.ts': { name: 'ESLint', command: 'eslint --fix', configFile: '.eslintrc' },
+    '.tsx': { name: 'ESLint', command: 'eslint --fix', configFile: '.eslintrc' },
+    '.js': { name: 'ESLint', command: 'eslint --fix', configFile: '.eslintrc' },
+    '.jsx': { name: 'ESLint', command: 'eslint --fix', configFile: '.eslintrc' },
+    '.py': { name: 'Pylint', command: 'pylint', configFile: 'pylintrc' },
+    '.go': { name: 'golangci-lint', command: 'golangci-lint run', configFile: '.golangci.yml' },
+    '.rs': { name: 'Clippy', command: 'cargo clippy', configFile: 'Cargo.toml' },
+    '.rb': { name: 'RuboCop', command: 'rubocop', configFile: '.rubocop.yml' },
+    '.php': { name: 'PHPStan', command: 'phpstan analyse', configFile: 'phpstan.neon' },
+};
+/**
+ * Naming convention checks
+ */
+const NAMING_CONVENTIONS = [
+    { pattern: /^[a-z][a-z0-9-]*\.[a-z]+$/, convention: 'kebab-case', fileTypes: /\.(tsx?|jsx?|css|scss)$/ },
+    { pattern: /^[a-z][a-z0-9_]*\.[a-z]+$/, convention: 'snake_case', fileTypes: /\.py$/ },
+    { pattern: /^[a-z][a-z0-9_]*\.[a-z]+$/, convention: 'snake_case', fileTypes: /\.go$/ },
+    { pattern: /^[A-Z][a-zA-Z0-9]*\.[a-z]+$/, convention: 'PascalCase', fileTypes: /\.(java|kt|cs)$/ },
+];
+/**
+ * File Organization Hook Manager
+ */
+export class FileOrganizationHook {
+    registry;
+    projectRoot = process.cwd();
+    constructor(registry) {
+        this.registry = registry;
+        this.registerHooks();
+    }
+    /**
+     * Register file organization hooks
+     */
+    registerHooks() {
+        // Pre-edit hook
+        this.registry.register(HookEvent.PreEdit, this.analyzeFileOperation.bind(this), HookPriority.High, { name: 'file-organization:pre-edit' });
+        // Pre-write hook
+        this.registry.register(HookEvent.PreWrite, this.analyzeFileOperation.bind(this), HookPriority.High, { name: 'file-organization:pre-write' });
+    }
+    /**
+     * Analyze file operation for organization issues
+     */
+    async analyzeFileOperation(context) {
+        const fileInfo = context.file;
+        if (!fileInfo) {
+            return this.createResult(false, []);
+        }
+        const filePath = fileInfo.path;
+        const fileName = path.basename(filePath);
+        const dirName = path.dirname(filePath);
+        const ext = path.extname(filePath);
+        const issues = [];
+        const warnings = [];
+        let blocked = false;
+        let blockReason;
+        let suggestedPath;
+        let suggestedDirectory;
+        // Check if writing to root folder
+        const isRootWrite = this.isRootDirectory(dirName);
+        const fileTypeInfo = this.getFileTypeInfo(fileName);
+        if (isRootWrite && fileTypeInfo?.blockRoot) {
+            blocked = true;
+            blockReason = `Source files should not be written to root folder. Suggested: ${fileTypeInfo.directories[0]}`;
+            suggestedDirectory = fileTypeInfo.directories[0];
+            suggestedPath = path.join(suggestedDirectory, fileName).replace(/\\/g, '/');
+            issues.push({
+                type: 'root-write',
+                severity: 'error',
+                description: `${fileTypeInfo.type} files should not be in the root directory`,
+                suggestedFix: `Move to ${suggestedDirectory}`,
+            });
+        }
+        // Check if file is in wrong directory
+        if (!isRootWrite && fileTypeInfo) {
+            const isInCorrectDir = fileTypeInfo.directories.some(dir => this.normalizePath(dirName).includes(this.normalizePath(dir)));
+            if (!isInCorrectDir) {
+                issues.push({
+                    type: 'wrong-directory',
+                    severity: 'warning',
+                    description: `${fileTypeInfo.type} typically goes in: ${fileTypeInfo.directories.join(' or ')}`,
+                    suggestedFix: `Consider moving to ${fileTypeInfo.directories[0]}`,
+                });
+                warnings.push(`File may be in wrong directory. Expected: ${fileTypeInfo.directories.join(' or ')}`);
+            }
+        }
+        // Check naming convention
+        const namingIssue = this.checkNamingConvention(fileName, ext);
+        if (namingIssue) {
+            issues.push(namingIssue);
+            warnings.push(namingIssue.description);
+        }
+        // Get formatter recommendation
+        const formatter = this.getFormatterRecommendation(ext);
+        // Get linter recommendation
+        const linter = this.getLinterRecommendation(ext);
+        return {
+            success: true,
+            blocked,
+            blockReason,
+            suggestedPath,
+            suggestedDirectory,
+            formatter,
+            linter,
+            fileType: fileTypeInfo?.type,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            issues: issues.length > 0 ? issues : undefined,
+            abort: blocked,
+            data: blocked ? undefined : {
+                file: {
+                    ...fileInfo,
+                    path: suggestedPath || filePath,
+                },
+                metadata: {
+                    formatter: formatter?.command,
+                    linter: linter?.command,
+                },
+            },
+        };
+    }
+    /**
+     * Check if directory is root
+     */
+    isRootDirectory(dirName) {
+        const normalized = this.normalizePath(dirName);
+        return normalized === '.' ||
+            normalized === './' ||
+            normalized === '' ||
+            normalized === this.normalizePath(this.projectRoot);
+    }
+    /**
+     * Normalize path for comparison
+     */
+    normalizePath(p) {
+        return p.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
+    }
+    /**
+     * Get file type information
+     */
+    getFileTypeInfo(fileName) {
+        for (const info of FILE_TYPE_DIRECTORIES) {
+            if (info.pattern.test(fileName)) {
+                return {
+                    directories: info.directories,
+                    type: info.type,
+                    blockRoot: info.blockRoot,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check naming convention
+     */
+    checkNamingConvention(fileName, ext) {
+        for (const rule of NAMING_CONVENTIONS) {
+            if (rule.fileTypes.test(ext)) {
+                const baseName = fileName.replace(ext, '');
+                if (!rule.pattern.test(fileName)) {
+                    return {
+                        type: 'naming-convention',
+                        severity: 'info',
+                        description: `File name may not follow ${rule.convention} convention`,
+                        suggestedFix: `Consider renaming to follow ${rule.convention}`,
+                    };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Get formatter recommendation
+     */
+    getFormatterRecommendation(ext) {
+        return FORMATTERS[ext];
+    }
+    /**
+     * Get linter recommendation
+     */
+    getLinterRecommendation(ext) {
+        return LINTERS[ext];
+    }
+    /**
+     * Create result object
+     */
+    createResult(blocked, issues) {
+        return {
+            success: true,
+            blocked,
+            issues: issues.length > 0 ? issues : undefined,
+        };
+    }
+    /**
+     * Manually analyze a file path
+     */
+    async analyze(filePath) {
+        const context = {
+            event: HookEvent.PreEdit,
+            timestamp: new Date(),
+            file: {
+                path: filePath,
+                operation: 'write',
+            },
+        };
+        return this.analyzeFileOperation(context);
+    }
+    /**
+     * Get suggested directory for a file
+     */
+    getSuggestedDirectory(fileName) {
+        const info = this.getFileTypeInfo(fileName);
+        return info?.directories[0] || null;
+    }
+    /**
+     * Check if a file path would be blocked
+     */
+    wouldBlock(filePath) {
+        const fileName = path.basename(filePath);
+        const dirName = path.dirname(filePath);
+        const isRoot = this.isRootDirectory(dirName);
+        const info = this.getFileTypeInfo(fileName);
+        return isRoot && (info?.blockRoot ?? false);
+    }
+    /**
+     * Set project root directory
+     */
+    setProjectRoot(root) {
+        this.projectRoot = root;
+    }
+    /**
+     * Get all formatter recommendations
+     */
+    getAllFormatters() {
+        return { ...FORMATTERS };
+    }
+    /**
+     * Get all linter recommendations
+     */
+    getAllLinters() {
+        return { ...LINTERS };
+    }
+}
+/**
+ * Create file organization hook
+ */
+export function createFileOrganizationHook(registry) {
+    return new FileOrganizationHook(registry);
+}
+//# sourceMappingURL=file-organization.js.map

package/src/@claude-flow/shared/dist/hooks/safety/git-commit.d.ts

@@ -0,0 +1,158 @@
+/**
+ * V3 Git Commit Hook
+ *
+ * TypeScript conversion of V2 git-commit-hook.sh.
+ * Provides conventional commit formatting, JIRA ticket extraction,
+ * co-author addition, and commit message validation.
+ *
+ * @module v3/shared/hooks/safety/git-commit
+ */
+import { HookContext, HookResult } from '../types.js';
+import { HookRegistry } from '../registry.js';
+/**
+ * Git commit hook result
+ */
+export interface GitCommitResult extends HookResult {
+    /** Original commit message */
+    originalMessage: string;
+    /** Modified commit message */
+    modifiedMessage: string;
+    /** Detected commit type */
+    commitType?: CommitType;
+    /** Extracted ticket reference */
+    ticketReference?: string;
+    /** Whether co-author was added */
+    coAuthorAdded: boolean;
+    /** Validation issues */
+    validationIssues?: CommitValidationIssue[];
+    /** Suggestions for improvement */
+    suggestions?: string[];
+}
+/**
+ * Commit type definition
+ */
+export type CommitType = 'feat' | 'fix' | 'docs' | 'style' | 'refactor' | 'perf' | 'test' | 'build' | 'ci' | 'chore' | 'revert';
+/**
+ * Commit validation issue
+ */
+export interface CommitValidationIssue {
+    /** Issue type */
+    type: 'format' | 'length' | 'scope' | 'body' | 'breaking';
+    /** Issue severity */
+    severity: 'info' | 'warning' | 'error';
+    /** Issue description */
+    description: string;
+    /** Suggested fix */
+    suggestedFix?: string;
+}
+/**
+ * Co-author configuration
+ */
+interface CoAuthor {
+    name: string;
+    email: string;
+}
+/**
+ * Commit message configuration
+ */
+interface CommitConfig {
+    /** Maximum subject line length */
+    maxSubjectLength: number;
+    /** Maximum body line length */
+    maxBodyLength: number;
+    /** Require conventional commit format */
+    requireConventional: boolean;
+    /** Add co-author by default */
+    addCoAuthor: boolean;
+    /** Co-author to add */
+    coAuthor: CoAuthor;
+    /** Add Claude Code reference */
+    addClaudeReference: boolean;
+    /** Allowed scopes */
+    allowedScopes?: string[];
+}
+/**
+ * Git Commit Hook Manager
+ */
+export declare class GitCommitHook {
+    private registry;
+    private config;
+    constructor(registry: HookRegistry, config?: Partial<CommitConfig>);
+    /**
+     * Register git commit hooks
+     */
+    private registerHooks;
+    /**
+     * Handle pre-commit (when a git commit command is detected)
+     */
+    handlePreCommit(context: HookContext): Promise<HookResult>;
+    /**
+     * Process commit message
+     */
+    processCommitMessage(message: string, branchName?: string): Promise<GitCommitResult>;
+    /**
+     * Parse commit message into parts
+     */
+    private parseMessage;
+    /**
+     * Detect commit type from message
+     */
+    private detectCommitType;
+    /**
+     * Check if message has conventional commit prefix
+     */
+    private hasConventionalPrefix;
+    /**
+     * Lowercase first letter of a string
+     */
+    private lowercaseFirstLetter;
+    /**
+     * Extract ticket reference from branch name
+     */
+    private extractTicket;
+    /**
+     * Add ticket reference to message
+     */
+    private addTicketReference;
+    /**
+     * Validate conventional commit format
+     */
+    private validateConventional;
+    /**
+     * Process commit message manually
+     */
+    process(message: string, branchName?: string): Promise<GitCommitResult>;
+    /**
+     * Format a commit message with heredoc-style for git
+     */
+    formatForGit(message: string): string;
+    /**
+     * Generate a commit command with formatted message
+     */
+    generateCommitCommand(message: string): string;
+    /**
+     * Get commit type description
+     */
+    getCommitTypeDescription(type: CommitType): string;
+    /**
+     * Get all available commit types
+     */
+    getAllCommitTypes(): Array<{
+        type: CommitType;
+        description: string;
+    }>;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<CommitConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): CommitConfig;
+}
+/**
+ * Create git commit hook
+ */
+export declare function createGitCommitHook(registry: HookRegistry, config?: Partial<CommitConfig>): GitCommitHook;
+export {};
+//# sourceMappingURL=git-commit.d.ts.map