autoworkflow 1.0.0

package/README.md

@@ -0,0 +1,206 @@
+# autoworkflow
+
+Zero-config code quality enforcement. Just install and commit.
+
+[![npm version](https://img.shields.io/npm/v/autoworkflow.svg)](https://www.npmjs.com/package/autoworkflow)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Install
+
+```bash
+npm install autoworkflow --save-dev
+```
+
+**That's it.** Enforcement is now active on all commits.
+
+## What Happens
+
+```
+npm install autoworkflow
+         │
+         ▼
+  ┌──────────────────────────────────┐
+  │  Auto-setup (postinstall):       │
+  │  ✓ Creates .husky/pre-commit     │
+  │  ✓ Creates .husky/commit-msg     │
+  │  ✓ Creates enforce.config.json   │
+  │  ✓ Adds prepare script           │
+  └──────────────────────────────────┘
+         │
+         ▼
+  Every "git commit" runs checks automatically
+```
+
+## Default Checks
+
+| Check | Blocking | Auto-Fix |
+|-------|----------|----------|
+| No TODO/FIXME comments | ✅ | - |
+| No console.log | ✅ | - |
+| TypeScript errors | ✅ | - |
+| ESLint errors | ✅ | ✅ |
+| Circular dependencies | ✅ | - |
+| Commit message format | ✅ | - |
+
+## How It Works
+
+### Pre-Commit Hook
+Every time you run `git commit`, autoworkflow:
+1. Runs all enabled checks
+2. If ESLint fails, auto-fixes and retries (up to 5 attempts)
+3. Blocks commit if any blocking check fails
+4. Allows commit if all checks pass
+
+### Commit Message Validation
+Enforces [Conventional Commits](https://www.conventionalcommits.org/):
+
+```bash
+# ✅ Valid
+git commit -m "feat: add user authentication"
+git commit -m "fix(api): resolve timeout issue"
+git commit -m "docs: update installation guide"
+
+# ❌ Invalid (blocked)
+git commit -m "fixed stuff"
+git commit -m "WIP"
+```
+
+## Configuration
+
+Edit `enforce.config.json` in your project root:
+
+```json
+{
+  "rules": {
+    "no-todo-comments": {
+      "enabled": true,
+      "blocking": true,
+      "patterns": ["TODO", "FIXME", "XXX", "HACK"]
+    },
+    "no-console-logs": {
+      "enabled": true,
+      "blocking": true
+    },
+    "typescript": {
+      "enabled": true,
+      "blocking": true,
+      "command": "npx tsc --noEmit"
+    },
+    "eslint": {
+      "enabled": true,
+      "blocking": true,
+      "autoFix": true,
+      "command": "npx eslint . --max-warnings 0",
+      "fixCommand": "npx eslint . --fix"
+    },
+    "circular-deps": {
+      "enabled": true,
+      "blocking": true,
+      "paths": ["src/"]
+    }
+  },
+  "fixLoop": {
+    "enabled": true,
+    "maxAttempts": 5,
+    "autoFixRules": ["eslint"]
+  },
+  "commitMessage": {
+    "enabled": true,
+    "pattern": "^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\\(.+\\))?: .{1,72}$"
+  }
+}
+```
+
+### Rule Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `enabled` | boolean | Enable/disable the rule |
+| `blocking` | boolean | If true, fails the commit on violation |
+| `autoFix` | boolean | Enable auto-fix for this rule |
+| `command` | string | Custom check command |
+| `fixCommand` | string | Custom fix command |
+
+### Disable a Rule
+
+```json
+{
+  "rules": {
+    "no-console-logs": { "enabled": false }
+  }
+}
+```
+
+### Non-Blocking Warning
+
+```json
+{
+  "rules": {
+    "circular-deps": { "enabled": true, "blocking": false }
+  }
+}
+```
+
+## CLI Commands
+
+```bash
+# Run all checks manually
+npx autoworkflow run
+
+# List all rules and their status
+npx autoworkflow list
+
+# Validate a commit message
+npx autoworkflow commit-msg .git/COMMIT_EDITMSG
+
+# Show help
+npx autoworkflow --help
+```
+
+## Fix Loop
+
+When ESLint (or other auto-fixable rules) fail:
+
+```
+[1/5] ESLint... ❌
+     src/app.ts: 'unused' is defined but never used
+
+🔧 Attempting auto-fix...
+   ✅ Fixed: ESLint
+
+🔄 Fix Loop - Attempt 2/5
+
+[1/5] ESLint... ✅
+
+✅ ALL CHECKS PASSED
+```
+
+## Skip Enforcement (Emergency)
+
+```bash
+git commit --no-verify -m "emergency: hotfix for production"
+```
+
+Use sparingly. All skipped commits are your responsibility.
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Git repository (initialized with `git init`)
+
+### Optional Peer Dependencies
+
+- TypeScript >= 5.0.0 (for TypeScript checks)
+- ESLint >= 8.0.0 (for ESLint checks)
+
+## Uninstall
+
+```bash
+npm uninstall autoworkflow
+rm -rf .husky
+rm enforce.config.json
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+/**
+ * autoworkflow - CLI
+ *
+ * Usage:
+ *   npx autoworkflow run         Run all checks (with fix loop)
+ *   npx autoworkflow list        List all rules
+ *   npx autoworkflow check <id>  Run specific rule
+ *   npx autoworkflow commit-msg  Validate commit message
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+const log = (color, msg) => console.log(`${color}${msg}${c.reset}`);
+
+// Find config file
+function findConfig() {
+  const configPath = path.join(process.cwd(), 'enforce.config.json');
+  if (fs.existsSync(configPath)) {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  }
+  // Return defaults
+  return {
+    rules: {
+      'no-todo-comments': { enabled: true, blocking: true },
+      'no-console-logs': { enabled: true, blocking: true },
+      'typescript': { enabled: true, blocking: true },
+      'eslint': { enabled: true, blocking: true, autoFix: true },
+      'circular-deps': { enabled: true, blocking: true },
+    },
+    fixLoop: { enabled: true, maxAttempts: 5, autoFixRules: ['eslint'] },
+  };
+}
+
+// Rule implementations
+const rules = {
+  'no-todo-comments': {
+    name: 'No TODO/FIXME Comments',
+    check: (config) => {
+      try {
+        const patterns = config.patterns || ['TODO', 'FIXME', 'XXX', 'HACK'];
+        const output = execSync(
+          `grep -rn "${patterns.join('\\|')}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" . 2>/dev/null | grep -v node_modules | grep -v ".git" || true`,
+          { encoding: 'utf-8' }
+        ).trim();
+        const matches = output ? output.split('\n').filter(Boolean) : [];
+        return { passed: matches.length === 0, details: matches.slice(0, 5) };
+      } catch {
+        return { passed: true, details: [] };
+      }
+    },
+  },
+
+  'no-console-logs': {
+    name: 'No Console Logs',
+    check: (config) => {
+      try {
+        const output = execSync(
+          'grep -rn "console\\.\\(log\\|debug\\|info\\)" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" . 2>/dev/null | grep -v node_modules | grep -v ".git" | grep -v "eslint-disable" || true',
+          { encoding: 'utf-8' }
+        ).trim();
+        const matches = output ? output.split('\n').filter(Boolean) : [];
+        return { passed: matches.length === 0, details: matches.slice(0, 5) };
+      } catch {
+        return { passed: true, details: [] };
+      }
+    },
+  },
+
+  'typescript': {
+    name: 'TypeScript',
+    check: (config) => {
+      try {
+        const cmd = config.command || 'npx tsc --noEmit';
+        execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+        return { passed: true, details: [] };
+      } catch (error) {
+        const output = error.stdout || error.message || '';
+        const errors = output.split('\n').filter(l => l.includes('error')).slice(0, 5);
+        return { passed: false, details: errors };
+      }
+    },
+  },
+
+  'eslint': {
+    name: 'ESLint',
+    check: (config) => {
+      try {
+        const cmd = config.command || 'npx eslint . --max-warnings 0';
+        execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+        return { passed: true, details: [] };
+      } catch (error) {
+        const output = error.stdout || error.message || '';
+        const errors = output.split('\n').filter(l => l.includes('error') || l.includes('warning')).slice(0, 5);
+        return { passed: false, details: errors };
+      }
+    },
+    fix: (config) => {
+      try {
+        const cmd = config.fixCommand || 'npx eslint . --fix';
+        execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  },
+
+  'circular-deps': {
+    name: 'Circular Dependencies',
+    check: (config) => {
+      try {
+        const paths = config.paths || ['src/'];
+        const output = execSync(
+          `npx madge --circular --extensions ts,tsx,js,jsx ${paths.join(' ')} 2>&1`,
+          { encoding: 'utf-8' }
+        );
+        const hasCircular = output.includes('Found');
+        return { passed: !hasCircular, details: hasCircular ? output.split('\n').slice(0, 5) : [] };
+      } catch {
+        return { passed: true, details: [] };
+      }
+    },
+  },
+};
+
+// Run all checks with fix loop
+function runChecks(config) {
+  const fixLoop = config.fixLoop || { enabled: true, maxAttempts: 5 };
+  let attempt = 0;
+  let results = [];
+  const fixedRules = [];
+
+  log(c.blue, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log(c.blue, '🔒 autoworkflow');
+  log(c.blue, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  while (attempt < fixLoop.maxAttempts) {
+    attempt++;
+
+    if (attempt > 1) {
+      log(c.cyan, `\n🔄 Fix Loop - Attempt ${attempt}/${fixLoop.maxAttempts}\n`);
+    }
+
+    results = [];
+    let index = 0;
+    const ruleIds = Object.keys(config.rules).filter(id => config.rules[id]?.enabled);
+
+    for (const ruleId of ruleIds) {
+      const rule = rules[ruleId];
+      const ruleConfig = config.rules[ruleId];
+      if (!rule) continue;
+
+      index++;
+      const result = rule.check(ruleConfig);
+      const status = result.passed ? c.green + '✅' : (ruleConfig.blocking ? c.red + '❌' : c.yellow + '⚠️');
+
+      console.log(`${c.yellow}[${index}/${ruleIds.length}]${c.reset} ${rule.name}... ${status}${c.reset}`);
+
+      if (!result.passed && result.details.length > 0) {
+        result.details.forEach(d => console.log(`     ${d}`));
+      }
+
+      results.push({ ruleId, ...result, blocking: ruleConfig.blocking, fixable: !!rule.fix && ruleConfig.autoFix });
+    }
+
+    // Check if we need to fix
+    const failedFixable = results.filter(
+      r => !r.passed && r.fixable && (fixLoop.autoFixRules || []).includes(r.ruleId)
+    );
+
+    if (failedFixable.length === 0) break;
+
+    // Attempt fixes
+    log(c.cyan, '\n🔧 Attempting auto-fix...');
+    for (const result of failedFixable) {
+      const rule = rules[result.ruleId];
+      const ruleConfig = config.rules[result.ruleId];
+      if (rule?.fix?.(ruleConfig)) {
+        log(c.green, `   ✅ Fixed: ${rule.name}`);
+        if (!fixedRules.includes(result.ruleId)) fixedRules.push(result.ruleId);
+      }
+    }
+  }
+
+  // Summary
+  const failed = results.filter(r => !r.passed && r.blocking).length;
+
+  console.log('');
+  log(c.blue, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  if (failed > 0) {
+    log(c.red, '⛔ COMMIT BLOCKED');
+    log(c.red, `   ${failed} check(s) failed. Fix issues and try again.`);
+    process.exit(1);
+  } else {
+    log(c.green, '✅ ALL CHECKS PASSED');
+    if (fixedRules.length > 0) {
+      log(c.green, `   Auto-fixed: ${fixedRules.join(', ')}`);
+    }
+  }
+  console.log('');
+}
+
+// Validate commit message
+function validateCommitMessage(msgFile) {
+  const config = findConfig();
+  const commitConfig = config.commitMessage || {};
+
+  if (!commitConfig.enabled) return;
+
+  const message = fs.readFileSync(msgFile, 'utf-8').trim().split('\n')[0];
+  const pattern = commitConfig.pattern || '^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\\(.+\\))?: .{1,72}$';
+
+  if (!new RegExp(pattern).test(message)) {
+    log(c.red, '');
+    log(c.red, '⛔ Invalid commit message format!');
+    log(c.red, '');
+    log(c.yellow, 'Expected: type(scope): description');
+    log(c.yellow, 'Examples:');
+    console.log('  feat: add user authentication');
+    console.log('  fix(auth): resolve login bug');
+    console.log('  docs: update readme');
+    log(c.red, '');
+    log(c.red, `Your message: "${message}"`);
+    log(c.red, '');
+    process.exit(1);
+  }
+}
+
+// List rules
+function listRules(config) {
+  log(c.blue, 'Available rules:');
+  console.log('');
+
+  for (const [id, ruleConfig] of Object.entries(config.rules)) {
+    const rule = rules[id];
+    const status = ruleConfig.enabled ? c.green + '✅' : c.red + '❌';
+    const blocking = ruleConfig.blocking ? '🔒' : '⚠️';
+    const name = rule?.name || id;
+    console.log(`  ${status}${c.reset} ${blocking} ${name} (${id})`);
+  }
+  console.log('');
+}
+
+// Main
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'run';
+  const config = findConfig();
+
+  switch (command) {
+    case 'run':
+      runChecks(config);
+      break;
+
+    case 'commit-msg':
+      const msgFile = args[1];
+      if (msgFile) validateCommitMessage(msgFile);
+      break;
+
+    case 'list':
+      listRules(config);
+      break;
+
+    case '--help':
+    case '-h':
+      console.log('');
+      log(c.blue, 'autoworkflow');
+      console.log('');
+      console.log('Usage:');
+      console.log('  npx autoworkflow run          Run all checks');
+      console.log('  npx autoworkflow list         List all rules');
+      console.log('  npx autoworkflow commit-msg   Validate commit message');
+      console.log('  npx autoworkflow --help       Show this help');
+      console.log('');
+      console.log('Configuration: enforce.config.json');
+      console.log('');
+      break;
+
+    default:
+      runChecks(config);
+  }
+}
+
+main();

package/lib/index.js

@@ -0,0 +1,9 @@
+/**
+ * autoworkflow
+ *
+ * Automatic code quality enforcement with fix loops.
+ */
+
+module.exports = {
+  version: '1.0.0',
+};

package/lib/install.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * autoworkflow - Auto-Install Script
+ *
+ * This runs automatically when the package is installed.
+ * Sets up Git hooks and creates default config.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Colors for output
+const c = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+};
+
+function log(color, message) {
+  console.log(`${color}${message}${c.reset}`);
+}
+
+function findProjectRoot() {
+  // Start from where npm install was run (not node_modules)
+  let dir = process.env.INIT_CWD || process.cwd();
+
+  // Walk up to find package.json (project root)
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      // Make sure it's not our own package.json
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+      if (pkg.name !== 'autoworkflow') {
+        return dir;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+
+  return process.env.INIT_CWD || process.cwd();
+}
+
+function isGitRepo(dir) {
+  return fs.existsSync(path.join(dir, '.git'));
+}
+
+function ensureHuskyDir(projectRoot) {
+  const huskyDir = path.join(projectRoot, '.husky');
+  if (!fs.existsSync(huskyDir)) {
+    fs.mkdirSync(huskyDir, { recursive: true });
+  }
+
+  // Create husky internal dir
+  const huskyInternalDir = path.join(huskyDir, '_');
+  if (!fs.existsSync(huskyInternalDir)) {
+    fs.mkdirSync(huskyInternalDir, { recursive: true });
+  }
+
+  return huskyDir;
+}
+
+function createPreCommitHook(huskyDir, projectRoot) {
+  const hookPath = path.join(huskyDir, 'pre-commit');
+
+  // Check if hook already exists
+  if (fs.existsSync(hookPath)) {
+    log(c.yellow, '  ⚠ Pre-commit hook already exists, skipping...');
+    return;
+  }
+
+  const hookContent = `#!/bin/bash
+# ============================================
+# autoworkflow - Pre-Commit Hook
+# ============================================
+# Auto-generated. Modify enforce.config.json to customize.
+# ============================================
+
+npx autoworkflow run
+`;
+
+  fs.writeFileSync(hookPath, hookContent);
+  fs.chmodSync(hookPath, '755');
+  log(c.green, '  ✓ Created pre-commit hook');
+}
+
+function createCommitMsgHook(huskyDir) {
+  const hookPath = path.join(huskyDir, 'commit-msg');
+
+  if (fs.existsSync(hookPath)) {
+    log(c.yellow, '  ⚠ Commit-msg hook already exists, skipping...');
+    return;
+  }
+
+  const hookContent = `#!/bin/bash
+# ============================================
+# autoworkflow - Commit Message Hook
+# ============================================
+
+npx autoworkflow commit-msg "$1"
+`;
+
+  fs.writeFileSync(hookPath, hookContent);
+  fs.chmodSync(hookPath, '755');
+  log(c.green, '  ✓ Created commit-msg hook');
+}
+
+function createDefaultConfig(projectRoot) {
+  const configPath = path.join(projectRoot, 'enforce.config.json');
+
+  if (fs.existsSync(configPath)) {
+    log(c.yellow, '  ⚠ Config file already exists, skipping...');
+    return;
+  }
+
+  const defaultConfig = {
+    version: '1.0.0',
+    rules: {
+      'no-todo-comments': {
+        enabled: true,
+        blocking: true,
+        patterns: ['TODO', 'FIXME', 'XXX', 'HACK']
+      },
+      'no-console-logs': {
+        enabled: true,
+        blocking: true,
+        allow: ['warn', 'error']
+      },
+      'typescript': {
+        enabled: true,
+        blocking: true,
+        command: 'npx tsc --noEmit'
+      },
+      'eslint': {
+        enabled: true,
+        blocking: true,
+        autoFix: true,
+        command: 'npx eslint . --max-warnings 0',
+        fixCommand: 'npx eslint . --fix'
+      },
+      'circular-deps': {
+        enabled: true,
+        blocking: true,
+        paths: ['src/']
+      }
+    },
+    fixLoop: {
+      enabled: true,
+      maxAttempts: 5,
+      autoFixRules: ['eslint']
+    },
+    commitMessage: {
+      enabled: true,
+      pattern: '^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\\(.+\\))?: .{1,72}$'
+    }
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+  log(c.green, '  ✓ Created enforce.config.json');
+}
+
+function initializeHusky(projectRoot) {
+  try {
+    // Initialize husky
+    execSync('npx husky', { cwd: projectRoot, stdio: 'ignore' });
+    log(c.green, '  ✓ Initialized husky');
+  } catch (error) {
+    // Husky might already be initialized, that's okay
+  }
+}
+
+function updatePackageJson(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    log(c.yellow, '  ⚠ No package.json found');
+    return;
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+  // Add prepare script for husky if not exists
+  if (!pkg.scripts) {
+    pkg.scripts = {};
+  }
+
+  if (!pkg.scripts.prepare) {
+    pkg.scripts.prepare = 'husky';
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    log(c.green, '  ✓ Added prepare script to package.json');
+  }
+}
+
+function main() {
+  console.log('');
+  log(c.blue, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log(c.blue, '🔧 autoworkflow - Setting up...');
+  log(c.blue, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  const projectRoot = findProjectRoot();
+
+  // Skip if we're in the package itself
+  if (projectRoot.includes('node_modules')) {
+    return;
+  }
+
+  log(c.blue, `Project root: ${projectRoot}`);
+  console.log('');
+
+  // Check if it's a git repo
+  if (!isGitRepo(projectRoot)) {
+    log(c.yellow, '⚠ Not a git repository. Initialize git first:');
+    log(c.yellow, '  git init');
+    console.log('');
+    return;
+  }
+
+  // Setup husky
+  const huskyDir = ensureHuskyDir(projectRoot);
+  initializeHusky(projectRoot);
+
+  // Create hooks
+  createPreCommitHook(huskyDir, projectRoot);
+  createCommitMsgHook(huskyDir);
+
+  // Create config
+  createDefaultConfig(projectRoot);
+
+  // Update package.json
+  updatePackageJson(projectRoot);
+
+  console.log('');
+  log(c.green, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log(c.green, '✅ Setup complete!');
+  log(c.green, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+  log(c.blue, 'Enforcement is now active. Just commit as usual:');
+  console.log('  git add .');
+  console.log('  git commit -m "feat: your feature"');
+  console.log('');
+  log(c.blue, 'Configuration: enforce.config.json');
+  log(c.blue, 'CLI commands: npx autoworkflow --help');
+  console.log('');
+}
+
+// Only run if this is the actual install (not during npm pack)
+if (!process.env.npm_config_ignore_scripts) {
+  main();
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "autoworkflow",
+  "version": "1.0.0",
+  "description": "Automatic code quality enforcement with fix loops, configurable rules, and Git hook integration",
+  "keywords": [
+    "git-hooks",
+    "pre-commit",
+    "eslint",
+    "typescript",
+    "code-quality",
+    "enforcement",
+    "husky",
+    "lint-staged",
+    "commitlint",
+    "autoworkflow"
+  ],
+  "author": "autoworkflow",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/autoworkflow/autoworkflow"
+  },
+  "homepage": "https://github.com/autoworkflow/autoworkflow#readme",
+  "bugs": {
+    "url": "https://github.com/autoworkflow/autoworkflow/issues"
+  },
+  "main": "lib/index.js",
+  "bin": {
+    "autoworkflow": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "templates"
+  ],
+  "scripts": {
+    "postinstall": "node lib/install.js"
+  },
+  "dependencies": {
+    "husky": "^9.1.7",
+    "madge": "^8.0.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0",
+    "eslint": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    },
+    "eslint": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}