Development Environment & Tools - 1/2

# The "cowboy coder" approach
git add .
git commit -m "stuff"
git push origin main

# Meanwhile, on another machine...
git pull origin main
# CONFLICT: Merge conflict in src/auth/userService.js
# Auto-merging failed; fix conflicts and then commit the result

#!/bin/bash
# setup-git-workflow.sh - Professional Git setup

# Configure Git for consistent authoring
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

# Enable helpful configurations
git config --global push.default simple
git config --global pull.rebase true
git config --global rerere.enabled true
git config --global merge.conflictstyle diff3

# Set up useful aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

# Advanced aliases for better workflow
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
git config --global alias.cleanup "!git branch --merged | grep -v '\\*\\|main\\|develop' | xargs -n 1 git branch -d"

echo "Git workflow configured successfully!"

#!/bin/bash
# feature-workflow.sh - Standardized feature development

feature_name="$1"
if [ -z "$feature_name" ]; then
    echo "Usage: ./feature-workflow.sh <feature-name>"
    exit 1
fi

# Start feature development
start_feature() {
    echo "🚀 Starting feature: $feature_name"

    # Ensure we're on main and up to date
    git checkout main
    git pull origin main

    # Create and switch to feature branch
    git checkout -b "feature/$feature_name"

    echo "✅ Feature branch 'feature/$feature_name' created and checked out"
}

# Complete feature development
complete_feature() {
    echo "🏁 Completing feature: $feature_name"

    # Ensure all changes are committed
    if [[ -n $(git status --porcelain) ]]; then
        echo "❌ Uncommitted changes found. Please commit or stash them."
        exit 1
    fi

    # Rebase against latest main
    git fetch origin
    git rebase origin/main

    # Push feature branch
    git push origin "feature/$feature_name"

    echo "✅ Feature branch pushed. Ready for pull request!"
}

# Execute based on current branch
current_branch=$(git branch --show-current)
if [ "$current_branch" = "main" ]; then
    start_feature
else
    complete_feature
fi

// commit-msg-hook.js - Git hook for enforcing commit standards
const fs = require("fs");
const path = require("path");

const commitMsgFile = process.argv[2];
const commitMsg = fs.readFileSync(commitMsgFile, "utf8").trim();

// Conventional Commits pattern
const conventionalPattern =
  /^(feat|fix|docs|style|refactor|perf|test|chore|ci|build)(\(.+\))?: .{1,50}/;

// Additional patterns for backend-specific commits
const backendPatterns = {
  api: /^(feat|fix)\(api\): .+/,
  db: /^(feat|fix|refactor)\(db\): .+/,
  auth: /^(feat|fix|security)\(auth\): .+/,
  config: /^(feat|fix|chore)\(config\): .+/,
};

class CommitValidator {
  validate(message) {
    const lines = message.split("\n");
    const header = lines[0];

    // Check basic conventional commits format
    if (!conventionalPattern.test(header)) {
      return {
        valid: false,
        error:
          "Commit message must follow Conventional Commits format:\n" +
          "type(scope): description\n\n" +
          "Types: feat, fix, docs, style, refactor, perf, test, chore, ci, build",
      };
    }

    // Check length constraints
    if (header.length > 72) {
      return {
        valid: false,
        error: "Commit header must be 72 characters or less",
      };
    }

    // Validate backend-specific scopes
    const hasBackendScope = Object.values(backendPatterns).some((pattern) =>
      pattern.test(header)
    );

    if (header.includes("(") && !hasBackendScope && !header.match(/\(ui\)|/)) {
      console.warn(
        "⚠️  Consider using backend-specific scopes: api, db, auth, config"
      );
    }

    return { valid: true };
  }
}

const validator = new CommitValidator();
const result = validator.validate(commitMsg);

if (!result.valid) {
  console.error("❌ Invalid commit message:");
  console.error(result.error);
  console.error("\nYour commit message:");
  console.error(`"${commitMsg}"`);
  process.exit(1);
}

console.log("✅ Commit message validated");

// package.json - The "hope it works" approach
{
  "dependencies": {
    "express": "^4.18.2",
    "mongoose": "^6.0.0",
    "jsonwebtoken": "*",
    "lodash": "~4.17.0"
  }
}

// package-manager.js - Intelligent dependency management
const fs = require("fs");
const { execSync } = require("child_process");
const semver = require("semver");

class DependencyManager {
  constructor() {
    this.packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
    this.lockFile = this.detectLockFile();
  }

  detectLockFile() {
    if (fs.existsSync("package-lock.json")) return "npm";
    if (fs.existsSync("yarn.lock")) return "yarn";
    if (fs.existsSync("pnpm-lock.yaml")) return "pnpm";
    return null;
  }

  // Analyze dependency security and health
  auditDependencies() {
    console.log("🔍 Analyzing dependency security...");

    try {
      const auditResult = execSync(`${this.lockFile} audit --json`, {
        encoding: "utf8",
      });
      const audit = JSON.parse(auditResult);

      if (audit.vulnerabilities) {
        this.reportVulnerabilities(audit.vulnerabilities);
      }

      this.checkOutdatedPackages();
      this.analyzeBundleSize();
    } catch (error) {
      console.error("Security audit failed:", error.message);
    }
  }

  reportVulnerabilities(vulnerabilities) {
    const critical = vulnerabilities.filter((v) => v.severity === "critical");
    const high = vulnerabilities.filter((v) => v.severity === "high");

    if (critical.length > 0) {
      console.error(`❌ ${critical.length} CRITICAL vulnerabilities found!`);
      critical.forEach((vuln) => {
        console.error(`   ${vuln.module_name}: ${vuln.title}`);
      });
    }

    if (high.length > 0) {
      console.warn(`⚠️  ${high.length} HIGH severity vulnerabilities found!`);
    }
  }

  // Check for outdated packages with intelligent updates
  checkOutdatedPackages() {
    const outdatedCmd =
      this.lockFile === "npm"
        ? "npm outdated --json"
        : this.lockFile === "yarn"
        ? "yarn outdated --json"
        : "pnpm outdated --json";

    try {
      const outdatedResult = execSync(outdatedCmd, { encoding: "utf8" });
      const outdated = JSON.parse(outdatedResult);

      this.suggestUpdates(outdated);
    } catch (error) {
      // npm outdated exits with code 1 when packages are outdated
      if (error.stdout) {
        const outdated = JSON.parse(error.stdout);
        this.suggestUpdates(outdated);
      }
    }
  }

  suggestUpdates(outdated) {
    Object.entries(outdated).forEach(([pkg, info]) => {
      const currentMajor = semver.major(info.current);
      const latestMajor = semver.major(info.latest);

      if (currentMajor < latestMajor) {
        console.warn(
          `🔄 ${pkg}: Major update available (${info.current} → ${info.latest})`
        );
        console.warn(`   ⚠️  Review breaking changes before updating`);
      } else {
        console.log(
          `📦 ${pkg}: Safe update available (${info.current} → ${info.latest})`
        );
      }
    });
  }

  // Analyze bundle size impact
  analyzeBundleSize() {
    try {
      const bundleAnalyzer = require("webpack-bundle-analyzer");
      console.log(
        "📊 Bundle size analysis available via webpack-bundle-analyzer"
      );
    } catch (error) {
      console.log(
        "💡 Consider adding webpack-bundle-analyzer for size analysis"
      );
    }
  }

  // Create dependency update strategy
  createUpdateStrategy() {
    const strategy = {
      immediate: [], // Patch updates
      scheduled: [], // Minor updates
      manual: [], // Major updates requiring review
    };

    // Implementation would categorize updates based on semver and criticality
    return strategy;
  }
}

// Usage
const depManager = new DependencyManager();
depManager.auditDependencies();

#!/bin/bash
# dependency-check.sh - Comprehensive dependency validation

check_lock_files() {
    echo "🔒 Checking lock file integrity..."

    # Verify package-lock.json matches package.json
    if [ -f "package-lock.json" ]; then
        npm ci --dry-run || {
            echo "❌ package-lock.json is out of sync with package.json"
            echo "Run 'npm install' to fix"
            exit 1
        }
    fi

    # Check for multiple lock files (common mistake)
    lock_count=0
    [ -f "package-lock.json" ] && ((lock_count++))
    [ -f "yarn.lock" ] && ((lock_count++))
    [ -f "pnpm-lock.yaml" ] && ((lock_count++))

    if [ $lock_count -gt 1 ]; then
        echo "⚠️  Multiple lock files detected! This can cause conflicts."
        ls -la *lock* | head -10
    fi
}

validate_dependencies() {
    echo "✅ Validating production dependencies..."

    # Check for dev dependencies in production code
    if grep -r "require.*webpack\|require.*jest\|require.*eslint" src/ 2>/dev/null; then
        echo "⚠️  Dev dependencies found in production code"
    fi

    # Verify all imports are satisfied
    node -e "
        const fs = require('fs');
        const path = require('path');

        function checkImports(dir) {
            const files = fs.readdirSync(dir);
            files.forEach(file => {
                const filePath = path.join(dir, file);
                if (fs.statSync(filePath).isDirectory()) {
                    checkImports(filePath);
                } else if (file.endsWith('.js')) {
                    const content = fs.readFileSync(filePath, 'utf8');
                    const imports = content.match(/require\\(['\"](.*?)['\"]\\)/g) || [];
                    imports.forEach(imp => {
                        const module = imp.match(/require\\(['\"](.*?)['\"]\\)/)[1];
                        if (!module.startsWith('./') && !module.startsWith('../')) {
                            try {
                                require.resolve(module);
                            } catch (e) {
                                console.log('Missing dependency:', module, 'in', filePath);
                            }
                        }
                    });
                }
            });
        }

        if (fs.existsSync('src')) checkImports('src');
    "
}

check_lock_files
validate_dependencies
echo "✅ Dependency validation complete"

// package.json - The "cross your fingers" build setup
{
  "scripts": {
    "start": "node server.js",
    "build": "webpack",
    "test": "jest"
  }
}

// build-system.js - Professional build orchestration
const { execSync, spawn } = require("child_process");
const fs = require("fs");
const path = require("path");

class BuildOrchestrator {
  constructor(config = {}) {
    this.config = {
      environment: process.env.NODE_ENV || "development",
      buildDir: "./dist",
      sourceDir: "./src",
      parallel: true,
      ...config,
    };

    this.tasks = new Map();
    this.setupDefaultTasks();
  }

  setupDefaultTasks() {
    // Pre-build validation
    this.addTask("validate", {
      description: "Validate code and dependencies",
      command: this.validateCode.bind(this),
      parallel: false,
      critical: true,
    });

    // Transpilation/compilation
    this.addTask("compile", {
      description: "Compile TypeScript/Babel",
      command: "tsc --noEmit && babel src --out-dir dist",
      dependsOn: ["validate"],
    });

    // Bundle creation
    this.addTask("bundle", {
      description: "Create optimized bundles",
      command: "webpack --mode production",
      dependsOn: ["compile"],
    });

    // Asset optimization
    this.addTask("optimize", {
      description: "Optimize assets",
      command: this.optimizeAssets.bind(this),
      dependsOn: ["bundle"],
      parallel: true,
    });

    // Generate manifests
    this.addTask("manifest", {
      description: "Generate build manifests",
      command: this.generateManifest.bind(this),
      dependsOn: ["optimize"],
    });
  }

  addTask(name, config) {
    this.tasks.set(name, {
      name,
      status: "pending",
      startTime: null,
      endTime: null,
      ...config,
    });
  }

  async validateCode() {
    console.log("🔍 Running pre-build validation...");

    // ESLint check
    try {
      execSync("npx eslint src/ --ext .js,.ts", { stdio: "inherit" });
    } catch (error) {
      throw new Error("ESLint validation failed");
    }

    // Type checking
    try {
      execSync("npx tsc --noEmit", { stdio: "inherit" });
    } catch (error) {
      throw new Error("TypeScript validation failed");
    }

    // Security audit
    try {
      execSync("npm audit --audit-level moderate", { stdio: "inherit" });
    } catch (error) {
      console.warn("⚠️  Security vulnerabilities found");
    }
  }

  async optimizeAssets() {
    console.log("⚡ Optimizing assets...");

    // Minify JSON files
    const jsonFiles = this.findFiles(this.config.buildDir, ".json");
    jsonFiles.forEach((file) => {
      const content = JSON.parse(fs.readFileSync(file, "utf8"));
      fs.writeFileSync(file, JSON.stringify(content));
    });

    // Compress images (if imagemin is available)
    try {
      execSync("npx imagemin dist/images/* --out-dir=dist/images", {
        stdio: "inherit",
      });
    } catch (error) {
      console.log("💡 Consider adding imagemin for image optimization");
    }
  }

  generateManifest() {
    console.log("📋 Generating build manifest...");

    const manifest = {
      buildTime: new Date().toISOString(),
      environment: this.config.environment,
      version: this.getVersion(),
      files: this.getBuildFiles(),
      checksums: this.generateChecksums(),
    };

    fs.writeFileSync(
      path.join(this.config.buildDir, "manifest.json"),
      JSON.stringify(manifest, null, 2)
    );
  }

  getVersion() {
    try {
      return execSync("git rev-parse --short HEAD", {
        encoding: "utf8",
      }).trim();
    } catch (error) {
      return require("./package.json").version;
    }
  }

  getBuildFiles() {
    return this.findFiles(this.config.buildDir).map((file) =>
      path.relative(this.config.buildDir, file)
    );
  }

  generateChecksums() {
    const crypto = require("crypto");
    const checksums = {};

    this.findFiles(this.config.buildDir).forEach((file) => {
      const content = fs.readFileSync(file);
      const hash = crypto.createHash("md5").update(content).digest("hex");
      checksums[path.relative(this.config.buildDir, file)] = hash;
    });

    return checksums;
  }

  findFiles(dir, ext = "") {
    const files = [];

    function scan(currentDir) {
      const entries = fs.readdirSync(currentDir);
      entries.forEach((entry) => {
        const fullPath = path.join(currentDir, entry);
        if (fs.statSync(fullPath).isDirectory()) {
          scan(fullPath);
        } else if (!ext || fullPath.endsWith(ext)) {
          files.push(fullPath);
        }
      });
    }

    scan(dir);
    return files;
  }

  async runTask(taskName) {
    const task = this.tasks.get(taskName);
    if (!task) throw new Error(`Task ${taskName} not found`);

    task.status = "running";
    task.startTime = Date.now();

    console.log(`🔄 ${task.description}...`);

    try {
      if (typeof task.command === "function") {
        await task.command();
      } else {
        execSync(task.command, { stdio: "inherit" });
      }

      task.status = "completed";
      task.endTime = Date.now();

      console.log(
        `✅ ${task.description} completed (${task.endTime - task.startTime}ms)`
      );
    } catch (error) {
      task.status = "failed";
      task.endTime = Date.now();

      console.error(`❌ ${task.description} failed:`, error.message);

      if (task.critical) {
        throw error;
      }
    }
  }

  async build() {
    console.log(
      `🚀 Starting build for ${this.config.environment} environment...`
    );

    // Clean build directory
    if (fs.existsSync(this.config.buildDir)) {
      fs.rmSync(this.config.buildDir, { recursive: true });
    }
    fs.mkdirSync(this.config.buildDir, { recursive: true });

    // Execute tasks in dependency order
    const executionPlan = this.createExecutionPlan();

    for (const phase of executionPlan) {
      if (this.config.parallel && phase.length > 1) {
        await Promise.all(phase.map((task) => this.runTask(task)));
      } else {
        for (const task of phase) {
          await this.runTask(task);
        }
      }
    }

    console.log("🎉 Build completed successfully!");
    this.printBuildSummary();
  }

  createExecutionPlan() {
    // Topological sort of tasks based on dependencies
    const plan = [];
    const visited = new Set();
    const visiting = new Set();

    const visit = (taskName) => {
      if (visiting.has(taskName)) {
        throw new Error(`Circular dependency detected: ${taskName}`);
      }
      if (visited.has(taskName)) return;

      visiting.add(taskName);
      const task = this.tasks.get(taskName);

      if (task.dependsOn) {
        task.dependsOn.forEach(visit);
      }

      visiting.delete(taskName);
      visited.add(taskName);

      // Add to appropriate phase
      const phase = task.dependsOn ? task.dependsOn.length : 0;
      if (!plan[phase]) plan[phase] = [];
      plan[phase].push(taskName);
    };

    Array.from(this.tasks.keys()).forEach(visit);
    return plan.filter((phase) => phase && phase.length > 0);
  }

  printBuildSummary() {
    console.log("\n📊 Build Summary:");
    const totalTime = Array.from(this.tasks.values()).reduce(
      (total, task) => total + (task.endTime - task.startTime),
      0
    );

    console.log(`   Total time: ${totalTime}ms`);

    Array.from(this.tasks.values()).forEach((task) => {
      const duration = task.endTime - task.startTime;
      const status = task.status === "completed" ? "✅" : "❌";
      console.log(`   ${status} ${task.name}: ${duration}ms`);
    });
  }
}

// Usage
const builder = new BuildOrchestrator({
  environment: process.env.NODE_ENV,
  parallel: true,
});

builder.build().catch((error) => {
  console.error("Build failed:", error);
  process.exit(1);
});

// formatter-config.js - Comprehensive formatting setup
const fs = require("fs");
const path = require("path");

class FormatterSetup {
  constructor() {
    this.configs = {
      prettier: {
        semi: true,
        singleQuote: true,
        tabWidth: 2,
        trailingComma: "es5",
        printWidth: 100,
        bracketSpacing: true,
        arrowParens: "avoid",
        endOfLine: "lf",
      },
      eslint: {
        extends: [
          "eslint:recommended",
          "@typescript-eslint/recommended",
          "prettier",
        ],
        plugins: ["@typescript-eslint", "import", "node"],
        parser: "@typescript-eslint/parser",
        parserOptions: {
          ecmaVersion: 2022,
          sourceType: "module",
        },
        env: {
          node: true,
          es2022: true,
        },
        rules: {
          // Code quality rules
          "no-console": "warn",
          "no-debugger": "error",
          "no-unused-vars": "error",
          "prefer-const": "error",

          // Import rules
          "import/order": [
            "error",
            {
              groups: ["builtin", "external", "internal", "parent", "sibling"],
              "newlines-between": "always",
            },
          ],

          // Node.js specific
          "node/no-process-exit": "error",
          "node/no-unpublished-require": "off",
        },
      },
      editorconfig: `# EditorConfig is awesome: https://EditorConfig.org

# top-most EditorConfig file
root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

[*.{js,ts,json}]
indent_size = 2

[*.md]
trim_trailing_whitespace = false

[Makefile]
indent_style = tab
`,
    };
  }

  setupFormatter() {
    console.log("🎨 Setting up code formatting...");

    // Create .prettierrc
    fs.writeFileSync(
      ".prettierrc",
      JSON.stringify(this.configs.prettier, null, 2)
    );

    // Create .eslintrc.js
    const eslintConfig = `module.exports = ${JSON.stringify(
      this.configs.eslint,
      null,
      2
    )};`;
    fs.writeFileSync(".eslintrc.js", eslintConfig);

    // Create .editorconfig
    fs.writeFileSync(".editorconfig", this.configs.editorconfig);

    // Create .prettierignore
    const prettierIgnore = `# Build outputs
dist/
build/
coverage/

# Dependencies
node_modules/

# Environment files
.env*

# Lock files
package-lock.json
yarn.lock
pnpm-lock.yaml

# Logs
*.log
`;
    fs.writeFileSync(".prettierignore", prettierIgnore);

    this.setupGitHooks();
    this.setupPackageScripts();

    console.log("✅ Code formatting configured successfully");
  }

  setupGitHooks() {
    const huskyConfig = {
      hooks: {
        "pre-commit": "lint-staged",
        "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
      },
    };

    const lintStagedConfig = {
      "*.{js,ts,json,md}": ["prettier --write", "git add"],
      "*.{js,ts}": ["eslint --fix", "git add"],
    };

    // Add to package.json
    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
    packageJson.husky = huskyConfig;
    packageJson["lint-staged"] = lintStagedConfig;

    fs.writeFileSync("package.json", JSON.stringify(packageJson, null, 2));
  }

  setupPackageScripts() {
    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));

    packageJson.scripts = {
      ...packageJson.scripts,
      format: 'prettier --write "src/**/*.{js,ts,json,md}"',
      "format:check": 'prettier --check "src/**/*.{js,ts,json,md}"',
      lint: "eslint src/ --ext .js,.ts",
      "lint:fix": "eslint src/ --ext .js,.ts --fix",
      "code:check": "npm run format:check && npm run lint",
      "code:fix": "npm run format && npm run lint:fix",
    };

    fs.writeFileSync("package.json", JSON.stringify(packageJson, null, 2));
  }

  // Validate existing code against formatting rules
  validateCodebase() {
    console.log("🔍 Validating existing codebase...");

    const { execSync } = require("child_process");

    try {
      // Check Prettier formatting
      execSync('npx prettier --check "src/**/*.{js,ts,json}"', {
        stdio: "inherit",
      });
      console.log("✅ All files are properly formatted");
    } catch (error) {
      console.log("⚠️  Some files need formatting. Run: npm run format");
    }

    try {
      // Check ESLint rules
      execSync("npx eslint src/ --ext .js,.ts", { stdio: "inherit" });
      console.log("✅ No linting errors found");
    } catch (error) {
      console.log("⚠️  Linting errors found. Run: npm run lint:fix");
    }
  }
}

// Auto-formatter integration for common editors
class EditorIntegration {
  generateVSCodeSettings() {
    const vscodeSettings = {
      "editor.formatOnSave": true,
      "editor.defaultFormatter": "esbenp.prettier-vscode",
      "editor.codeActionsOnSave": {
        "source.fixAll.eslint": true,
      },
      "files.eol": "\n",
      "files.insertFinalNewline": true,
      "files.trimTrailingWhitespace": true,
      "typescript.preferences.importModuleSpecifier": "relative",
    };

    const vscodeDir = ".vscode";
    if (!fs.existsSync(vscodeDir)) {
      fs.mkdirSync(vscodeDir);
    }

    fs.writeFileSync(
      path.join(vscodeDir, "settings.json"),
      JSON.stringify(vscodeSettings, null, 2)
    );

    // Recommended extensions
    const extensions = {
      recommendations: [
        "esbenp.prettier-vscode",
        "dbaeumer.vscode-eslint",
        "editorconfig.editorconfig",
        "bradlc.vscode-tailwindcss",
        "ms-vscode.vscode-typescript-next",
      ],
    };

    fs.writeFileSync(
      path.join(vscodeDir, "extensions.json"),
      JSON.stringify(extensions, null, 2)
    );
  }

  generateWebStormSettings() {
    // WebStorm/IntelliJ settings would go here
    console.log(
      "💡 For WebStorm: Enable Prettier and ESLint in Settings > Languages & Frameworks"
    );
  }
}

// Usage
const formatter = new FormatterSetup();
formatter.setupFormatter();
formatter.validateCodebase();

const editorIntegration = new EditorIntegration();
editorIntegration.generateVSCodeSettings();

// .vscode/settings.json - Professional VS Code setup
{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true,
    "source.organizeImports": true
  },
  "editor.rulers": [80, 120],
  "editor.minimap.enabled": true,
  "editor.bracketPairColorization.enabled": true,
  "editor.guides.bracketPairs": "active",

  // File management
  "files.exclude": {
    "**/node_modules": true,
    "**/dist": true,
    "**/.git": true,
    "**/coverage": true
  },
  "files.watcherExclude": {
    "**/node_modules/**": true,
    "**/dist/**": true
  },

  // Search configuration
  "search.exclude": {
    "**/node_modules": true,
    "**/dist": true,
    "**/coverage": true,
    "**/*.lock": true
  },

  // JavaScript/TypeScript specific
  "javascript.preferences.importModuleSpecifier": "relative",
  "typescript.preferences.importModuleSpecifier": "relative",
  "javascript.updateImportsOnFileMove.enabled": "always",
  "typescript.updateImportsOnFileMove.enabled": "always",

  // Debugging configuration
  "debug.inlineValues": "on",
  "debug.toolBarLocation": "docked",

  // Terminal integration
  "terminal.integrated.fontSize": 14,
  "terminal.integrated.shell.osx": "/bin/zsh",

  // Git integration
  "git.enableSmartCommit": true,
  "git.confirmSync": false,
  "git.autofetch": true,

  // Extension specific settings
  "eslint.workingDirectories": ["src"],
  "prettier.requireConfig": true,
  "emmet.includeLanguages": {
    "javascript": "javascriptreact"
  }
}

// .vscode/launch.json - Debugging configuration
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Node.js App",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/src/server.js",
      "env": {
        "NODE_ENV": "development",
        "DEBUG": "*"
      },
      "console": "integratedTerminal",
      "restart": true,
      "runtimeArgs": ["--inspect"]
    },
    {
      "name": "Debug Express API",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/src/app.js",
      "env": {
        "NODE_ENV": "development",
        "PORT": "3001"
      },
      "console": "integratedTerminal",
      "skipFiles": ["<node_internals>/**"]
    },
    {
      "name": "Debug Tests",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/node_modules/.bin/jest",
      "args": ["--runInBand", "--no-cache"],
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "env": {
        "NODE_ENV": "test"
      }
    },
    {
      "name": "Attach to Process",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "restart": true,
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/app"
    }
  ]
}

// .vscode/tasks.json - Task automation
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "npm: start",
      "type": "npm",
      "script": "start",
      "group": "build",
      "presentation": {
        "echo": true,
        "reveal": "always",
        "focus": false,
        "panel": "shared"
      },
      "problemMatcher": "$eslint-stylish"
    },
    {
      "label": "npm: test",
      "type": "npm",
      "script": "test",
      "group": "test",
      "presentation": {
        "echo": true,
        "reveal": "always",
        "focus": false,
        "panel": "shared"
      }
    },
    {
      "label": "Docker: Build",
      "type": "shell",
      "command": "docker build -t ${workspaceFolderBasename} .",
      "group": "build",
      "presentation": {
        "echo": true,
        "reveal": "always",
        "panel": "new"
      }
    },
    {
      "label": "Code Quality Check",
      "type": "shell",
      "command": "npm run code:check",
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "presentation": {
        "echo": true,
        "reveal": "always",
        "focus": false,
        "panel": "shared"
      },
      "problemMatcher": ["$eslint-stylish"]
    }
  ]
}

// productivity-setup.js - IDE productivity automation
const fs = require("fs");
const path = require("path");
const { execSync } = require("child_process");

class ProductivitySetup {
  constructor() {
    this.workspaceFolder = process.cwd();
    this.vscodeDir = path.join(this.workspaceFolder, ".vscode");
  }

  setupWorkspace() {
    console.log("🚀 Setting up productivity workspace...");

    if (!fs.existsSync(this.vscodeDir)) {
      fs.mkdirSync(this.vscodeDir);
    }

    this.createSnippets();
    this.setupKeybindings();
    this.installRecommendedExtensions();
    this.createDevelopmentScripts();

    console.log("✅ Productivity workspace configured!");
  }

  createSnippets() {
    const snippets = {
      javascript: {
        "Express Route Handler": {
          prefix: "route",
          body: [
            "router.${1:get}('/${2:path}', async (req, res) => {",
            "  try {",
            "    ${3:// Implementation}",
            "    res.json({ success: true, data: ${4:result} });",
            "  } catch (error) {",
            "    logger.error('Error in ${2:path}:', error);",
            "    res.status(500).json({ error: 'Internal server error' });",
            "  }",
            "});",
          ],
          description: "Express route handler with error handling",
        },
        "Async Function with Error Handling": {
          prefix: "asyncfn",
          body: [
            "const ${1:functionName} = async (${2:params}) => {",
            "  try {",
            "    ${3:// Implementation}",
            "  } catch (error) {",
            "    logger.error('Error in ${1:functionName}:', error);",
            "    throw error;",
            "  }",
            "};",
          ],
          description: "Async function with try-catch",
        },
        "Database Model Schema": {
          prefix: "schema",
          body: [
            "const ${1:modelName}Schema = new mongoose.Schema({",
            "  ${2:field}: {",
            "    type: ${3:String},",
            "    required: ${4:true},",
            "    ${5:unique: true}",
            "  }",
            "}, {",
            "  timestamps: true,",
            "  toJSON: { virtuals: true },",
            "  toObject: { virtuals: true }",
            "});",
            "",
            "module.exports = mongoose.model('${1:modelName}', ${1:modelName}Schema);",
          ],
          description: "Mongoose schema definition",
        },
      },
    };

    fs.writeFileSync(
      path.join(this.vscodeDir, "snippets.json"),
      JSON.stringify(snippets, null, 2)
    );
  }

  setupKeybindings() {
    const keybindings = [
      {
        key: "ctrl+shift+r",
        command: "workbench.action.tasks.runTask",
        args: "npm: start",
      },
      {
        key: "ctrl+shift+t",
        command: "workbench.action.tasks.runTask",
        args: "npm: test",
      },
      {
        key: "ctrl+shift+b",
        command: "workbench.action.tasks.runTask",
        args: "Code Quality Check",
      },
      {
        key: "ctrl+shift+d",
        command: "workbench.action.debug.start",
      },
    ];

    fs.writeFileSync(
      path.join(this.vscodeDir, "keybindings.json"),
      JSON.stringify(keybindings, null, 2)
    );
  }

  installRecommendedExtensions() {
    const extensions = [
      "esbenp.prettier-vscode",
      "dbaeumer.vscode-eslint",
      "ms-vscode.vscode-typescript-next",
      "bradlc.vscode-tailwindcss",
      "ms-python.python",
      "ms-vscode.vscode-json",
      "redhat.vscode-yaml",
      "ms-vscode.vscode-docker",
      "gitpod.gitpod-desktop",
    ];

    console.log("📦 Installing recommended extensions...");
    extensions.forEach((ext) => {
      try {
        execSync(`code --install-extension ${ext}`, { stdio: "inherit" });
      } catch (error) {
        console.warn(`Failed to install ${ext}:`, error.message);
      }
    });
  }

  createDevelopmentScripts() {
    const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));

    packageJson.scripts = {
      ...packageJson.scripts,
      dev: "nodemon src/server.js",
      "dev:debug": "nodemon --inspect src/server.js",
      clean: "rm -rf dist/ coverage/ .nyc_output/",
      reset:
        "npm run clean && rm -rf node_modules package-lock.json && npm install",
      health: "npm run code:check && npm test && npm run build",
    };

    fs.writeFileSync("package.json", JSON.stringify(packageJson, null, 2));
  }
}

// Usage
const productivity = new ProductivitySetup();
productivity.setupWorkspace();

#!/bin/bash
# professional-workflow.sh - Complete development workflow

setup_project() {
    echo "🏗️  Setting up professional development environment..."

    # Initialize Git with proper configuration
    git init
    git config --local user.name "$(git config --global user.name)"
    git config --local user.email "$(git config --global user.email)"

    # Set up branch protection
    git checkout -b main

    # Initialize npm with professional defaults
    npm init -y

    # Install development dependencies
    npm install --save-dev \
        eslint \
        prettier \
        husky \
        lint-staged \
        @typescript-eslint/parser \
        @typescript-eslint/eslint-plugin \
        nodemon \
        jest \
        supertest

    # Create directory structure
    mkdir -p src/{controllers,models,routes,middleware,utils,config}
    mkdir -p tests/{unit,integration,e2e}
    mkdir -p docs

    echo "✅ Project structure created"
}

configure_tools() {
    echo "⚙️  Configuring development tools..."

    # Run our configuration scripts
    node -e "
        const FormatterSetup = require('./formatter-config.js');
        const ProductivitySetup = require('./productivity-setup.js');

        const formatter = new FormatterSetup();
        formatter.setupFormatter();

        const productivity = new ProductivitySetup();
        productivity.setupWorkspace();
    "

    # Initialize Husky
    npx husky install
    npx husky add .husky/pre-commit "npx lint-staged"
    npx husky add .husky/commit-msg "npx commitlint --edit \$1"

    echo "✅ Tools configured"
}

create_sample_files() {
    echo "📝 Creating sample files..."

    # Create sample server file
    cat > src/server.js << 'EOF'
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware
app.use(helmet());
app.use(cors());
app.use(morgan('combined'));
app.use(express.json({ limit: '10mb' }));

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'OK', timestamp: new Date().toISOString() });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

module.exports = app;
EOF

    # Create sample test
    cat > tests/integration/server.test.js << 'EOF'
const request = require('supertest');
const app = require('../../src/server');

describe('Server Integration Tests', () => {
  test('Health check endpoint', async () => {
    const response = await request(app).get('/health');
    expect(response.status).toBe(200);
    expect(response.body.status).toBe('OK');
  });
});
EOF

    echo "✅ Sample files created"
}

# Execute setup
setup_project
configure_tools
create_sample_files

echo "🎉 Professional development environment ready!"
echo ""
echo "Next steps:"
echo "1. npm run dev - Start development server"
echo "2. npm test - Run tests"
echo "3. npm run code:check - Validate code quality"
echo "4. git add . && git commit -m 'feat: initial project setup'"