@fredlackey/devutils 0.0.18 → 0.1.0

package/src/patterns/gitignore/python.txt

@@ -0,0 +1,55 @@
+# Python
+# Patterns for Python projects.
+
+# Byte-compiled files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution and packaging
+dist/
+build/
+*.egg-info/
+*.egg
+eggs/
+wheels/
+sdist/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Environment and secrets
+.env
+.env.*
+!.env.example
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test and coverage
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+nosetests.xml
+
+# Type checker cache
+.mypy_cache/
+.pytype/
+.pyre/
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# pyenv
+.python-version

package/src/patterns/gitignore/rust.txt

@@ -0,0 +1,14 @@
+# Rust
+# Patterns for Rust projects.
+
+# Compiled output
+target/
+
+# Cargo.lock for libraries (remove this line for applications)
+# Cargo.lock
+
+# Backup files generated by rustfmt
+*.rs.bk
+
+# MSVC debug information
+*.pdb

package/src/patterns/gitignore/terraform.txt

@@ -0,0 +1,30 @@
+# Terraform
+# Patterns for Terraform and OpenTofu infrastructure-as-code projects.
+
+# Provider plugins and modules
+.terraform/
+
+# State files (contain secrets -- never commit these)
+*.tfstate
+*.tfstate.*
+
+# Crash logs
+crash.log
+crash.*.log
+
+# Variable files that may contain secrets
+*.tfvars
+*.tfvars.json
+!*.tfvars.example
+
+# Override files (local developer overrides)
+override.tf
+override.tf.json
+*_override.tf
+*_override.tf.json
+
+# Plan files (binary, can contain secrets)
+*.tfplan
+
+# Lock file (commit this for consistent provider versions)
+# .terraform.lock.hcl

package/src/patterns/gitignore/vscode.txt

@@ -0,0 +1,15 @@
+# Visual Studio Code
+# Patterns for VS Code workspace and user-level files.
+
+# Workspace settings (user-specific)
+.vscode/
+
+# Workspace file
+*.code-workspace
+
+# VS Code local history
+.history/
+
+# VS Code extensions recommendation (optional -- remove this line
+# if your team uses shared extension recommendations)
+# .vscode/extensions.json

package/src/patterns/gitignore/windows.txt

@@ -0,0 +1,25 @@
+# Windows
+# Patterns for Windows system and Explorer metadata files.
+
+# Thumbnail cache
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Folder config
+desktop.ini
+Desktop.ini
+
+# Recycle Bin
+$RECYCLE.BIN/
+
+# Shortcut files
+*.lnk
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp

package/src/utils/clone/index.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const meta = {
+  name: 'clone',
+  description: 'Clone a git repo and auto-install dependencies using the detected package manager',
+  platforms: ['macos', 'ubuntu', 'raspbian', 'amazon-linux', 'windows', 'gitbash'],
+  arguments: [
+    { name: 'url', required: true, description: 'Git repository URL (SSH or HTTPS)' },
+    { name: 'directory', required: false, description: 'Target directory name (defaults to repo name)' },
+  ],
+  flags: [],
+};
+
+/**
+ * Extract the repository name from a git URL.
+ * Handles HTTPS, SSH, and bare path formats.
+ *
+ * @param {string} url - The git repository URL.
+ * @returns {string} The extracted repo name.
+ */
+function extractRepoName(url) {
+  let cleaned = url.replace(/\/+$/, '');
+  cleaned = cleaned.replace(/\.git$/, '');
+
+  const lastSegment = cleaned.split('/').pop() || '';
+
+  if (lastSegment.includes(':')) {
+    return lastSegment.split(':').pop() || 'cloned-repo';
+  }
+
+  return lastSegment || 'cloned-repo';
+}
+
+/**
+ * Detect which package manager to use based on lock files in the directory.
+ * Checks lock files in order: yarn.lock, pnpm-lock.yaml, package-lock.json.
+ * Falls back to npm if no lock file is found but package.json exists.
+ *
+ * @param {string} dir - The directory to check.
+ * @returns {{ name: string, installCmd: string }|null} Package manager info, or null if not a JS project.
+ */
+function detectPackageManager(dir) {
+  const hasPackageJson = fs.existsSync(path.join(dir, 'package.json'));
+  if (!hasPackageJson) {
+    return null;
+  }
+
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) {
+    return { name: 'yarn', installCmd: 'yarn install' };
+  }
+
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) {
+    return { name: 'pnpm', installCmd: 'pnpm install' };
+  }
+
+  if (fs.existsSync(path.join(dir, 'package-lock.json'))) {
+    return { name: 'npm', installCmd: 'npm install' };
+  }
+
+  // package.json exists but no lock file -- default to npm
+  return { name: 'npm', installCmd: 'npm install' };
+}
+
+/**
+ * Check if a command is available on the system.
+ *
+ * @param {string} cmd - The command name to check.
+ * @returns {boolean} True if the command exists on PATH.
+ */
+function isAvailable(cmd) {
+  const shell = require('../../lib/shell');
+  return shell.commandExists(cmd);
+}
+
+async function run(args) {
+  const shell = require('../../lib/shell');
+
+  if (!shell.commandExists('git')) {
+    console.error('Error: git is not installed.');
+    console.error('Install git first, then try again.');
+    return;
+  }
+
+  const url = args[0];
+  if (!url) {
+    console.error('Usage: dev util run clone <url> [directory]');
+    console.error('');
+    console.error('Examples:');
+    console.error('  dev util run clone git@github.com:user/repo.git');
+    console.error('  dev util run clone https://github.com/user/repo.git');
+    console.error('  dev util run clone git@github.com:user/repo.git my-project');
+    return;
+  }
+
+  const targetDir = args[1] || extractRepoName(url);
+  const fullPath = path.resolve(process.cwd(), targetDir);
+
+  if (fs.existsSync(fullPath)) {
+    console.error(`Error: Directory "${targetDir}" already exists.`);
+    return;
+  }
+
+  console.log(`Cloning ${url} into ${targetDir}...`);
+  console.log('');
+
+  const cloneResult = spawnSync('git', ['clone', url, targetDir], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+  });
+
+  if (cloneResult.status !== 0) {
+    console.error('');
+    console.error('git clone failed.');
+    return;
+  }
+
+  if (!fs.existsSync(fullPath)) {
+    console.error('Clone appeared to succeed but the directory was not created.');
+    return;
+  }
+
+  const pm = detectPackageManager(fullPath);
+
+  if (!pm) {
+    console.log('');
+    console.log(`Cloned into "${targetDir}".`);
+    console.log('No package.json found -- skipping dependency installation.');
+    return;
+  }
+
+  if (!isAvailable(pm.name)) {
+    console.log('');
+    console.log(`Cloned into "${targetDir}".`);
+    console.log(`package.json found, but ${pm.name} is not installed.`);
+    console.log(`Install ${pm.name} and run: ${pm.installCmd}`);
+    return;
+  }
+
+  console.log('');
+  console.log(`Installing dependencies with ${pm.name}...`);
+  console.log('');
+
+  const installResult = spawnSync(pm.name, ['install'], {
+    stdio: 'inherit',
+    cwd: fullPath,
+    shell: true,
+  });
+
+  if (installResult.status !== 0) {
+    console.error('');
+    console.error(`${pm.name} install finished with errors. Check the output above.`);
+  } else {
+    console.log('');
+    console.log('Dependencies installed.');
+  }
+
+  console.log('');
+  console.log(`Done. To enter the project: cd ${targetDir}`);
+}
+
+module.exports = { meta, run };

package/src/utils/git-push/index.js

@@ -0,0 +1,230 @@
+'use strict';
+
+const meta = {
+  name: 'git-push',
+  description: 'Safer git push: shows what will be pushed, confirms before pushing, and protects main/master',
+  platforms: ['macos', 'ubuntu', 'raspbian', 'amazon-linux', 'windows', 'gitbash'],
+  arguments: [
+    { name: 'message', required: true, description: 'Commit message (all arguments after the name are joined)' },
+  ],
+  flags: [
+    { name: 'force', type: 'boolean', description: 'Allow pushing to protected branches (main/master)' },
+    { name: 'yes', type: 'boolean', description: 'Skip the confirmation prompt' },
+  ],
+};
+
+const shell = require('../../lib/shell');
+
+/**
+ * Check if the current directory is inside a git repo.
+ * @returns {boolean}
+ */
+function isGitRepo() {
+  const result = shell.execSync('git rev-parse --is-inside-work-tree');
+  return result === 'true';
+}
+
+/**
+ * Get the current branch name.
+ * @returns {string|null} Branch name, or null if in detached HEAD state.
+ */
+function getCurrentBranch() {
+  return shell.execSync('git symbolic-ref --short HEAD') || null;
+}
+
+/**
+ * Get a list of changed files (staged, unstaged, and untracked).
+ * @returns {Array<{ status: string, file: string }>}
+ */
+function getChangedFiles() {
+  const result = shell.execSync('git status --porcelain');
+  if (!result) return [];
+
+  return result.split('\n').filter(Boolean).map(line => {
+    const status = line.substring(0, 2).trim();
+    const file = line.substring(3);
+    return { status, file };
+  });
+}
+
+/**
+ * Get the list of commits that would be pushed (ahead of remote).
+ * @returns {string[]} Array of commit summary lines.
+ */
+function getUnpushedCommits() {
+  const result = shell.execSync('git log @{upstream}..HEAD --oneline');
+  if (!result) return [];
+  return result.split('\n').filter(Boolean);
+}
+
+/**
+ * Check if there is a tracking branch configured.
+ * @returns {boolean}
+ */
+function hasTrackingBranch() {
+  const result = shell.execSync('git rev-parse --abbrev-ref @{upstream}');
+  return result !== null;
+}
+
+/**
+ * Check if --force flag was passed.
+ * @param {string[]} args - Raw args array.
+ * @param {object} context - Command context.
+ * @returns {boolean}
+ */
+function isForceFlag(args, context) {
+  if (context && context.flags && context.flags.force) return true;
+  return args.includes('--force');
+}
+
+/**
+ * Check if --yes flag was passed.
+ * @param {string[]} args - Raw args array.
+ * @param {object} context - Command context.
+ * @returns {boolean}
+ */
+function isYesFlag(args, context) {
+  if (context && context.flags && context.flags.yes) return true;
+  return args.includes('--yes') || args.includes('-y');
+}
+
+/**
+ * Convert a git status code to a human-readable label.
+ * @param {string} status - Status code from git status --porcelain.
+ * @returns {string}
+ */
+function statusLabel(status) {
+  const labels = {
+    'M': 'modified',
+    'A': 'added',
+    'D': 'deleted',
+    'R': 'renamed',
+    'C': 'copied',
+    '?': 'untracked',
+    '!': 'ignored',
+  };
+  const char = status.replace(/\s/g, '') || '?';
+  return labels[char[0]] || status;
+}
+
+async function run(args, context) {
+  if (!shell.commandExists('git')) {
+    console.error('Error: git is not installed.');
+    return;
+  }
+
+  if (!isGitRepo()) {
+    console.error('Error: Not inside a git repository.');
+    return;
+  }
+
+  // Filter out flags from args to build the commit message
+  const messageArgs = args.filter(a => !a.startsWith('--') && a !== '-y');
+  const message = messageArgs.join(' ').trim();
+  if (!message) {
+    console.error('Usage: dev util run git-push "your commit message"');
+    console.error('');
+    console.error('All arguments after the utility name become the commit message.');
+    console.error('Example: dev util run git-push Fix the login button color');
+    return;
+  }
+
+  const branch = getCurrentBranch();
+  if (!branch) {
+    console.error('Error: Not on a branch (detached HEAD).');
+    console.error('Check out a branch first: git checkout <branch>');
+    return;
+  }
+
+  // Check for protected branches
+  const protectedBranches = ['main', 'master'];
+  if (protectedBranches.includes(branch) && !isForceFlag(args, context)) {
+    console.error(`Warning: You are on the "${branch}" branch.`);
+    console.error('Pushing directly to this branch is usually not recommended.');
+    console.error('');
+
+    if (!context || !context.prompt) {
+      console.error('Use --force to push to protected branches in non-interactive mode.');
+      return;
+    }
+
+    const proceed = await context.prompt.confirm(
+      `Are you sure you want to push directly to ${branch}?`,
+      false
+    );
+    if (!proceed) {
+      console.log('Cancelled.');
+      return;
+    }
+  }
+
+  const changedFiles = getChangedFiles();
+  const existingUnpushed = hasTrackingBranch() ? getUnpushedCommits() : [];
+
+  if (changedFiles.length === 0 && existingUnpushed.length === 0) {
+    console.log('Nothing to commit or push. Working tree is clean.');
+    return;
+  }
+
+  // Display what will happen
+  console.log('');
+  console.log(`Branch: ${branch}`);
+  console.log(`Commit message: "${message}"`);
+  console.log('');
+
+  if (changedFiles.length > 0) {
+    console.log(`Files to be committed (${changedFiles.length}):`);
+    for (const f of changedFiles) {
+      const label = statusLabel(f.status);
+      console.log(`  ${label} ${f.file}`);
+    }
+    console.log('');
+  }
+
+  if (existingUnpushed.length > 0) {
+    console.log(`Already unpushed commits (${existingUnpushed.length}):`);
+    for (const c of existingUnpushed) {
+      console.log(`  ${c}`);
+    }
+    console.log('');
+  }
+
+  // Confirm
+  if (!isYesFlag(args, context)) {
+    if (context && context.prompt) {
+      const ok = await context.prompt.confirm('Proceed with commit and push?', true);
+      if (!ok) {
+        console.log('Cancelled.');
+        return;
+      }
+    }
+  }
+
+  // Execute: add, commit, push
+  console.log('Staging all changes...');
+  const addResult = await shell.exec('git add -A');
+  if (addResult.exitCode !== 0) {
+    console.error('git add failed: ' + addResult.stderr);
+    return;
+  }
+
+  console.log('Committing...');
+  const escapedMessage = message.replace(/"/g, '\\"');
+  const commitResult = await shell.exec(`git commit -m "${escapedMessage}"`);
+  if (commitResult.exitCode !== 0) {
+    console.error('git commit failed: ' + commitResult.stderr);
+    return;
+  }
+
+  console.log(`Pushing to origin/${branch}...`);
+  const pushResult = await shell.exec(`git push origin "${branch}"`);
+  if (pushResult.exitCode !== 0) {
+    console.error('git push failed: ' + pushResult.stderr);
+    return;
+  }
+
+  console.log('');
+  console.log('Done. Changes committed and pushed.');
+}
+
+module.exports = { meta, run };

package/src/utils/git-status/index.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const meta = {
+  name: 'git-status',
+  description: 'Scan directories for git repos and show a color-coded status summary',
+  platforms: ['macos', 'ubuntu', 'raspbian', 'amazon-linux', 'windows', 'gitbash'],
+  arguments: [
+    { name: 'path', required: false, description: 'Directory to scan (defaults to current directory)' },
+  ],
+  flags: [
+    { name: 'depth', type: 'number', description: 'How many levels deep to scan for repos (default: 1)' },
+  ],
+};
+
+/**
+ * Run the Unix bash script for git status scanning.
+ * @param {string} dir - The directory to scan.
+ */
+async function runUnixScript(dir) {
+  const shell = require('../../lib/shell');
+  const scriptPath = path.join(__dirname, 'unix.sh');
+
+  const result = await shell.exec(`bash "${scriptPath}" "${dir}"`);
+
+  if (result.exitCode !== 0) {
+    console.error(result.stderr || 'git-status script failed');
+    return;
+  }
+
+  if (result.stdout) {
+    console.log(result.stdout);
+  }
+}
+
+/**
+ * Pure JavaScript fallback for platforms without bash (Windows, Git Bash).
+ * @param {string} dir - The directory to scan.
+ */
+async function runJsFallback(dir) {
+  const shell = require('../../lib/shell');
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const repos = entries
+    .filter(e => e.isDirectory() && fs.existsSync(path.join(dir, e.name, '.git')))
+    .map(e => ({ name: e.name, path: path.join(dir, e.name) }));
+
+  if (repos.length === 0) {
+    console.log('No git repositories found in ' + dir);
+    return;
+  }
+
+  for (const repo of repos) {
+    const opts = { cwd: repo.path };
+
+    // Get branch
+    let branch = shell.execSync('git symbolic-ref --short HEAD', opts);
+    if (branch === null) branch = 'detached';
+
+    // Get dirty count
+    const porcelain = shell.execSync('git status --porcelain', opts) || '';
+    const dirtyCount = porcelain ? porcelain.split('\n').filter(Boolean).length : 0;
+
+    // Get stash count
+    const stashList = shell.execSync('git stash list', opts) || '';
+    const stashCount = stashList ? stashList.split('\n').filter(Boolean).length : 0;
+
+    // Get ahead/behind
+    let ahead = 0;
+    let behind = 0;
+    const tracking = shell.execSync('git rev-parse --abbrev-ref @{upstream}', opts);
+    if (tracking) {
+      const counts = shell.execSync('git rev-list --left-right --count HEAD...@{upstream}', opts);
+      if (counts) {
+        const parts = counts.split(/\s+/);
+        ahead = parseInt(parts[0], 10) || 0;
+        behind = parseInt(parts[1], 10) || 0;
+      }
+    }
+
+    // Build status string
+    const statusParts = [];
+    if (dirtyCount > 0) statusParts.push(`${dirtyCount} dirty`);
+    if (ahead > 0) statusParts.push(`+${ahead}`);
+    if (behind > 0) statusParts.push(`-${behind}`);
+    if (stashCount > 0) statusParts.push(`${stashCount} stash`);
+    if (statusParts.length === 0) statusParts.push('clean');
+
+    const nameCol = repo.name.padEnd(30);
+    const branchCol = branch.padEnd(20);
+    console.log(`${nameCol} ${branchCol} ${statusParts.join('  ')}`);
+  }
+}
+
+async function run(args) {
+  const platform = require('../../lib/platform').detect();
+  const targetDir = args[0] || process.cwd();
+  const resolvedDir = path.resolve(targetDir);
+
+  if (!fs.existsSync(resolvedDir)) {
+    console.error(`Directory not found: ${resolvedDir}`);
+    return;
+  }
+
+  const unixPlatforms = ['macos', 'ubuntu', 'raspbian', 'amazon-linux'];
+
+  if (unixPlatforms.includes(platform.type)) {
+    await runUnixScript(resolvedDir);
+  } else {
+    await runJsFallback(resolvedDir);
+  }
+}
+
+module.exports = { meta, run };