brain-dev 0.1.0

package/bin/lib/detect.cjs

@@ -0,0 +1,603 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+const { isGitRepo } = require('./git.cjs');
+
+/**
+ * Manifest files with tier-based priority.
+ * Backend manifests take priority over frontend tooling (package.json).
+ * When both composer.json and package.json exist, composer.json is primary.
+ */
+const MANIFEST_FILES = [
+  // Tier: backend — language-specific manifests (primary stack)
+  { file: 'composer.json', language: 'php', tier: 'backend' },
+  { file: 'Gemfile', language: 'ruby', tier: 'backend' },
+  { file: 'go.mod', language: 'go', tier: 'backend' },
+  { file: 'Cargo.toml', language: 'rust', tier: 'backend' },
+  { file: 'pom.xml', language: 'java', tier: 'backend' },
+  { file: 'build.gradle', language: 'java', tier: 'backend' },
+  { file: 'mix.exs', language: 'elixir', tier: 'backend' },
+  { file: 'pyproject.toml', language: 'python', tier: 'backend' },
+  { file: 'requirements.txt', language: 'python', tier: 'backend' },
+  { file: 'setup.py', language: 'python', tier: 'backend' },
+  { file: 'pubspec.yaml', language: 'dart', tier: 'backend' },
+  // Tier: frontend — often tooling alongside a backend manifest
+  { file: 'package.json', language: 'javascript', tier: 'frontend' }
+];
+
+/**
+ * Framework detection from package.json dependency names.
+ */
+const FRAMEWORK_MAP = {
+  'next': 'Next.js',
+  '@next/': 'Next.js',
+  'nuxt': 'Nuxt',
+  'react-native': 'React Native',
+  'expo': 'Expo',
+  'react': 'React',
+  'react-dom': 'React',
+  'vue': 'Vue.js',
+  '@angular/core': 'Angular',
+  'svelte': 'Svelte',
+  '@sveltejs/kit': 'SvelteKit',
+  'express': 'Express',
+  'fastify': 'Fastify',
+  '@nestjs/core': 'NestJS',
+  'hono': 'Hono',
+  'koa': 'Koa',
+  'remix': 'Remix',
+  '@remix-run/': 'Remix',
+  'gatsby': 'Gatsby',
+  'astro': 'Astro',
+  'laravel-mix': 'Laravel',
+  'laravel-vite-plugin': 'Laravel',
+  '@inertiajs/vue3': 'Inertia.js',
+  '@inertiajs/react': 'Inertia.js',
+  'electron': 'Electron'
+};
+
+/**
+ * Feature detection from npm dependency names.
+ */
+const FEATURE_MAP = {
+  'prisma': 'Database/ORM',
+  '@prisma/client': 'Database/ORM',
+  'typeorm': 'Database/ORM',
+  'sequelize': 'Database/ORM',
+  'mongoose': 'Database/ORM',
+  'drizzle-orm': 'Database/ORM',
+  'knex': 'Database/ORM',
+  'passport': 'Authentication',
+  'next-auth': 'Authentication',
+  '@auth/': 'Authentication',
+  'jsonwebtoken': 'Authentication',
+  'bcrypt': 'Authentication',
+  'stripe': 'Payments',
+  '@stripe/': 'Payments',
+  'socket.io': 'Real-time',
+  'ws': 'Real-time',
+  'pusher': 'Real-time',
+  'bull': 'Job Queues',
+  'bullmq': 'Job Queues',
+  'redis': 'Caching',
+  'ioredis': 'Caching',
+  'jest': 'Testing',
+  'vitest': 'Testing',
+  'mocha': 'Testing',
+  '@testing-library/': 'Testing',
+  'tailwindcss': 'Tailwind CSS',
+  'styled-components': 'CSS-in-JS',
+  '@emotion/': 'CSS-in-JS',
+  'graphql': 'GraphQL',
+  '@apollo/': 'GraphQL',
+  'trpc': 'tRPC',
+  '@trpc/': 'tRPC'
+};
+
+/**
+ * Feature detection from composer.json dependency names.
+ */
+const COMPOSER_FEATURE_MAP = {
+  'laravel/sanctum': 'Authentication',
+  'laravel/passport': 'Authentication',
+  'laravel/fortify': 'Authentication',
+  'laravel/socialite': 'OAuth',
+  'laravel/horizon': 'Job Queues',
+  'laravel/cashier': 'Payments',
+  'laravel/scout': 'Search',
+  'laravel/telescope': 'Debugging',
+  'predis/predis': 'Caching',
+  'doctrine/orm': 'Database/ORM',
+  'doctrine/dbal': 'Database/ORM',
+  'symfony/mailer': 'Email',
+  'phpunit/phpunit': 'Testing',
+  'pestphp/pest': 'Testing',
+  'spatie/laravel-permission': 'Authorization',
+  'spatie/laravel-medialibrary': 'File Storage'
+};
+
+/**
+ * Frontend framework detection (when package.json is secondary manifest).
+ */
+const FE_FRAMEWORK_MAP = {
+  'vue': 'Vue.js',
+  'react': 'React',
+  'react-dom': 'React',
+  '@angular/core': 'Angular',
+  'svelte': 'Svelte',
+  'alpinejs': 'Alpine.js',
+  'livewire': 'Livewire'
+};
+
+const BUNDLER_MAP = { 'vite': 'Vite', 'webpack': 'Webpack', 'esbuild': 'esbuild', 'turbo': 'Turborepo', 'parcel': 'Parcel' };
+const CSS_MAP = { 'tailwindcss': 'Tailwind CSS', 'styled-components': 'CSS-in-JS', '@emotion/react': 'CSS-in-JS', 'sass': 'Sass', 'less': 'Less' };
+
+/**
+ * Common source code directories to check.
+ */
+const CODE_DIRS = ['src', 'lib', 'app', 'pages', 'components', 'api', 'cmd', 'pkg', 'internal', 'server', 'client', 'modules', 'routes', 'resources', 'database'];
+
+/**
+ * Source file extensions to count.
+ */
+const CODE_EXTENSIONS = new Set(['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', '.rb', '.php', '.ex', '.exs', '.dart', '.swift', '.kt', '.cs', '.vue', '.svelte', '.blade.php']);
+
+/**
+ * Detect project type, stack, and workspace from a directory.
+ * Supports multi-manifest detection (e.g., composer.json + package.json for Laravel).
+ * Lightweight, synchronous — no agent spawning.
+ *
+ * @param {string} rootDir - Project root directory
+ * @returns {{ type: string, signals: object, stack: object, features: string[], workspace: object|null, summary: string }}
+ */
+function detectProject(rootDir) {
+  // 1. Collect ALL present manifests (no break on first match)
+  const foundManifests = [];
+  for (const entry of MANIFEST_FILES) {
+    if (fs.existsSync(path.join(rootDir, entry.file))) {
+      foundManifests.push(entry);
+    }
+  }
+
+  // Determine primary (backend) and frontend manifests
+  const primaryManifest = foundManifests.find(m => m.tier === 'backend') || foundManifests[0] || null;
+  const frontendManifest = foundManifests.find(m => m.tier === 'frontend' && m !== primaryManifest) || null;
+
+  const signals = {
+    manifest: primaryManifest ? primaryManifest.file : null,
+    manifests: foundManifests.map(m => m.file),
+    git: false,
+    commitCount: 0,
+    codeFiles: 0,
+    codeDirs: []
+  };
+
+  const stack = {
+    primary: { language: null, framework: null, runtime: null, dependencies: [] },
+    frontend: null
+  };
+
+  const features = [];
+
+  // 2. Parse primary manifest
+  if (primaryManifest) {
+    stack.primary.language = primaryManifest.language;
+
+    if (primaryManifest.file === 'package.json') {
+      const pkgInfo = parsePackageJson(rootDir);
+      if (pkgInfo) {
+        stack.primary.framework = pkgInfo.framework;
+        stack.primary.runtime = pkgInfo.runtime;
+        stack.primary.dependencies = pkgInfo.topDeps;
+        if (pkgInfo.hasTypeScript) stack.primary.language = 'typescript';
+        // Feature detection from npm deps
+        addFeaturesFromDeps(pkgInfo.allDeps, FEATURE_MAP, features);
+      }
+    } else if (primaryManifest.file === 'composer.json') {
+      const composerInfo = parseComposerJson(rootDir);
+      if (composerInfo) {
+        stack.primary.framework = composerInfo.framework;
+        stack.primary.dependencies = composerInfo.topDeps;
+        // Feature detection from composer deps
+        addFeaturesFromDeps(composerInfo.allDeps, COMPOSER_FEATURE_MAP, features);
+      }
+    } else if (primaryManifest.file === 'go.mod') {
+      const goInfo = parseGoMod(rootDir);
+      if (goInfo) {
+        stack.primary.dependencies = goInfo.deps;
+        stack.primary.runtime = 'go';
+      }
+    }
+  }
+
+  // 3. Parse frontend manifest (when separate from primary)
+  if (frontendManifest && frontendManifest !== primaryManifest) {
+    const pkgInfo = parsePackageJson(rootDir);
+    if (pkgInfo) {
+      stack.frontend = extractFrontendInfo(pkgInfo);
+      // Also detect features from npm deps
+      addFeaturesFromDeps(pkgInfo.allDeps, FEATURE_MAP, features);
+    }
+  }
+
+  // 4. Backward compat: expose flat stack properties from primary
+  stack.language = stack.primary.language;
+  stack.framework = stack.primary.framework;
+  stack.runtime = stack.primary.runtime;
+  stack.dependencies = stack.primary.dependencies;
+
+  // 5. Git detection
+  signals.git = isGitRepo(rootDir);
+  if (signals.git) {
+    signals.commitCount = getCommitCount(rootDir);
+  }
+
+  // 6. Code directory detection
+  for (const dir of CODE_DIRS) {
+    const dirPath = path.join(rootDir, dir);
+    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+      signals.codeDirs.push(dir + '/');
+    }
+  }
+
+  // 7. Code file counting
+  signals.codeFiles = countCodeFiles(rootDir, signals.codeDirs);
+
+  // 8. Classification
+  const hasDeps = signals.manifest && stack.primary.dependencies.length > 0;
+  const hasCode = signals.codeDirs.length > 0 && signals.codeFiles > 0;
+  const hasHistory = signals.git && signals.commitCount >= 5;
+
+  const type = (hasDeps || hasCode || hasHistory) ? 'brownfield' : 'greenfield';
+
+  // 9. Workspace detection (sibling projects)
+  const workspace = detectWorkspace(rootDir);
+
+  // 10. Summary
+  const summary = buildSummary(type, stack, signals, features);
+
+  return { type, signals, stack, features, workspace, summary };
+}
+
+/**
+ * Add features from dependency list using a feature map.
+ * @param {string[]} deps
+ * @param {object} featureMap
+ * @param {string[]} features - mutated
+ */
+function addFeaturesFromDeps(deps, featureMap, features) {
+  for (const dep of deps) {
+    for (const [pattern, feature] of Object.entries(featureMap)) {
+      if (dep === pattern || dep.startsWith(pattern)) {
+        if (!features.includes(feature)) {
+          features.push(feature);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Extract frontend-specific info from package.json when it's the secondary manifest.
+ * @param {object} pkgInfo - Result from parsePackageJson()
+ * @returns {{ framework: string|null, bundler: string|null, css: string|null, dependencies: string[] }}
+ */
+function extractFrontendInfo(pkgInfo) {
+  let framework = null, bundler = null, css = null;
+
+  for (const dep of pkgInfo.allDeps) {
+    if (!framework) {
+      for (const [p, n] of Object.entries(FE_FRAMEWORK_MAP)) {
+        if (dep === p || dep.startsWith(p)) { framework = n; break; }
+      }
+    }
+    if (!bundler) {
+      for (const [p, n] of Object.entries(BUNDLER_MAP)) {
+        if (dep === p) { bundler = n; break; }
+      }
+    }
+    if (!css) {
+      for (const [p, n] of Object.entries(CSS_MAP)) {
+        if (dep === p || dep.startsWith(p)) { css = n; break; }
+      }
+    }
+  }
+
+  return { framework, bundler, css, dependencies: pkgInfo.topDeps };
+}
+
+/**
+ * Detect sibling projects sharing a common name prefix.
+ * Lightweight scan of parent directory for related repos.
+ *
+ * @param {string} rootDir - Current project root
+ * @returns {{ root: string, siblings: Array<{ name: string, path: string, stack: object }> }|null}
+ */
+function detectWorkspace(rootDir) {
+  const projectName = path.basename(rootDir);
+  const parentDir = path.dirname(rootDir);
+
+  // Extract prefix: "resumeshift" from "resumeshift", "resumeshift-rn", "resumeshift-landing"
+  const prefix = projectName.split(/[-_]/)[0];
+  if (prefix.length < 3) return null;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(parentDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  const siblings = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === projectName) continue;
+    if (!entry.name.startsWith(prefix)) continue;
+    if (siblings.length >= 5) break; // cap at 5
+
+    const sibPath = path.join(parentDir, entry.name);
+    const lightResult = detectProjectLight(sibPath);
+    if (lightResult) {
+      siblings.push({
+        name: entry.name,
+        path: sibPath,
+        stack: lightResult
+      });
+    }
+  }
+
+  return siblings.length > 0 ? { root: parentDir, siblings } : null;
+}
+
+/**
+ * Lightweight project detection — only checks first manifest and framework.
+ * No git, file counting, or feature detection. Should complete in < 50ms.
+ *
+ * @param {string} dir
+ * @returns {{ language: string, framework: string|null }|null}
+ */
+function detectProjectLight(dir) {
+  for (const { file, language } of MANIFEST_FILES) {
+    if (fs.existsSync(path.join(dir, file))) {
+      let framework = null;
+      if (file === 'package.json') {
+        const info = parsePackageJson(dir);
+        if (info) framework = info.framework;
+      } else if (file === 'composer.json') {
+        const info = parseComposerJson(dir);
+        if (info) framework = info.framework;
+      }
+      return { language, framework };
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse package.json to extract framework, runtime, and dependencies.
+ * @param {string} rootDir
+ * @returns {object|null}
+ */
+function parsePackageJson(rootDir) {
+  try {
+    const content = fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8');
+    const pkg = JSON.parse(content);
+
+    const deps = Object.keys(pkg.dependencies || {});
+    const devDeps = Object.keys(pkg.devDependencies || {});
+    const allDeps = [...deps, ...devDeps];
+
+    // Framework detection
+    let framework = null;
+    for (const dep of allDeps) {
+      for (const [pattern, name] of Object.entries(FRAMEWORK_MAP)) {
+        if (dep === pattern || dep.startsWith(pattern)) {
+          framework = name;
+          break;
+        }
+      }
+      if (framework) break;
+    }
+
+    // Runtime detection
+    let runtime = 'node';
+    if (allDeps.includes('bun') || (pkg.scripts && JSON.stringify(pkg.scripts).includes('bun '))) {
+      runtime = 'bun';
+    }
+    if (allDeps.includes('deno')) {
+      runtime = 'deno';
+    }
+
+    // TypeScript detection
+    const hasTypeScript = allDeps.includes('typescript') || allDeps.some(d => d.startsWith('@types/'));
+
+    // Top 10 most significant deps (skip type definitions)
+    const topDeps = deps.filter(d => !d.startsWith('@types/')).slice(0, 10);
+
+    return { framework, runtime, hasTypeScript, topDeps, allDeps };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse go.mod to extract module dependencies.
+ * @param {string} rootDir
+ * @returns {object|null}
+ */
+function parseGoMod(rootDir) {
+  try {
+    const content = fs.readFileSync(path.join(rootDir, 'go.mod'), 'utf8');
+    const deps = [];
+    const lines = content.split('\n');
+    let inRequire = false;
+
+    for (const line of lines) {
+      if (line.trim() === 'require (') { inRequire = true; continue; }
+      if (line.trim() === ')') { inRequire = false; continue; }
+      if (inRequire) {
+        const match = line.trim().match(/^(\S+)/);
+        if (match) {
+          const parts = match[1].split('/');
+          deps.push(parts[parts.length - 1]);
+        }
+      }
+    }
+
+    return { deps: deps.slice(0, 10) };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse composer.json for PHP/Laravel/Symfony projects.
+ * Includes feature detection from require and require-dev.
+ * @param {string} rootDir
+ * @returns {object|null}
+ */
+function parseComposerJson(rootDir) {
+  try {
+    const content = fs.readFileSync(path.join(rootDir, 'composer.json'), 'utf8');
+    const pkg = JSON.parse(content);
+    const requireDeps = Object.keys(pkg.require || {}).filter(d => d !== 'php');
+    const requireDevDeps = Object.keys(pkg['require-dev'] || {});
+    const allDeps = [...requireDeps, ...requireDevDeps];
+    const topDeps = requireDeps.slice(0, 10);
+
+    let framework = null;
+    if (allDeps.some(d => d.startsWith('laravel/'))) framework = 'Laravel';
+    if (allDeps.includes('symfony/framework-bundle')) framework = 'Symfony';
+
+    return { framework, topDeps, allDeps };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get git commit count for a repository.
+ * @param {string} dir
+ * @returns {number}
+ */
+function getCommitCount(dir) {
+  try {
+    const output = execSync('git rev-list --count HEAD', {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return parseInt(output.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Count source code files in discovered directories (1-level deep).
+ * @param {string} rootDir
+ * @param {string[]} codeDirs - Directory names with trailing slash
+ * @returns {number}
+ */
+function countCodeFiles(rootDir, codeDirs) {
+  let count = 0;
+
+  // Count files in root dir (shallow)
+  try {
+    const rootFiles = fs.readdirSync(rootDir);
+    for (const file of rootFiles) {
+      const ext = path.extname(file);
+      if (CODE_EXTENSIONS.has(ext)) count++;
+    }
+  } catch { /* ignore */ }
+
+  // Count files in code dirs (1-level deep)
+  for (const dir of codeDirs) {
+    const dirName = dir.replace(/\/$/, '');
+    const dirPath = path.join(rootDir, dirName);
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (CODE_EXTENSIONS.has(ext)) count++;
+        } else if (entry.isDirectory()) {
+          try {
+            const subEntries = fs.readdirSync(path.join(dirPath, entry.name));
+            for (const sub of subEntries) {
+              const ext = path.extname(sub);
+              if (CODE_EXTENSIONS.has(ext)) count++;
+            }
+          } catch { /* ignore */ }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  return count;
+}
+
+/**
+ * Build a human-readable project summary string.
+ * Supports multi-stack (primary + frontend) format.
+ * @param {string} type
+ * @param {object} stack
+ * @param {object} signals
+ * @param {string[]} features
+ * @returns {string}
+ */
+function buildSummary(type, stack, signals, features) {
+  if (type === 'greenfield') {
+    return 'New project (no existing code detected)';
+  }
+
+  const parts = [];
+
+  // Primary stack
+  const primary = stack.primary || stack;
+  if (primary.framework) {
+    if (primary.language) {
+      parts.push(`${primary.framework} (${primary.language})`);
+    } else {
+      parts.push(primary.framework);
+    }
+  } else if (primary.language) {
+    parts.push(primary.language.charAt(0).toUpperCase() + primary.language.slice(1));
+  }
+  // Backward compat: handle old flat stack shape
+  else if (stack.framework) {
+    parts.push(stack.framework);
+  }
+
+  // Frontend stack
+  if (stack.frontend) {
+    const feParts = [stack.frontend.framework, stack.frontend.bundler, stack.frontend.css].filter(Boolean);
+    if (feParts.length > 0) {
+      parts.push(`+ ${feParts.join('/')} frontend`);
+    }
+  }
+
+  // Features mention
+  if (features.length > 0) {
+    const featureStr = features.slice(0, 3).join(', ');
+    parts.push(`with ${featureStr}`);
+  }
+
+  // Size
+  const sizeStr = signals.codeFiles > 0 ? `${signals.codeFiles} source files` : null;
+  const commitStr = signals.commitCount > 0 ? `${signals.commitCount} commits` : null;
+
+  if (sizeStr && commitStr) {
+    parts.push(`(${sizeStr}, ${commitStr})`);
+  } else if (sizeStr) {
+    parts.push(`(${sizeStr})`);
+  } else if (commitStr) {
+    parts.push(`(${commitStr})`);
+  }
+
+  return parts.join(' ') || 'Existing project';
+}
+
+module.exports = { detectProject, detectProjectLight, detectWorkspace, extractFrontendInfo, parsePackageJson, parseComposerJson, getCommitCount, countCodeFiles, buildSummary };

package/bin/lib/git.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+const { execSync, execFileSync } = require('node:child_process');
+
+/**
+ * Check if a directory is inside a git working tree.
+ * @param {string} dir - Directory to check
+ * @returns {boolean}
+ */
+function isGitRepo(dir) {
+  try {
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: dir,
+      stdio: 'pipe'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initialize a git repository in the given directory.
+ * Idempotent: safe to call if .git/ already exists.
+ * @param {string} dir - Directory to initialize
+ * @returns {boolean} true on success
+ */
+function gitInit(dir) {
+  try {
+    execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Stage specific files and create a commit.
+ * Uses execFileSync to prevent shell injection via file paths or messages.
+ * @param {string} message - Commit message (e.g. 'chore: initialize brain')
+ * @param {string[]} files - Array of file paths to stage (relative to dir)
+ * @param {string} dir - Working directory
+ * @returns {boolean} true on success, false on failure (empty commit, no changes)
+ */
+function gitCommit(message, files, dir) {
+  try {
+    if (!files || files.length === 0) {
+      return false;
+    }
+
+    // Stage specific files - safe from shell injection
+    execFileSync('git', ['add', ...files], { cwd: dir, stdio: 'pipe' });
+
+    // Commit - safe from shell injection
+    execFileSync('git', ['commit', '-m', message], {
+      cwd: dir,
+      stdio: 'pipe'
+    });
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get git status as structured data.
+ * @param {string} dir - Working directory
+ * @returns {Array<{status: string, file: string}>} Array of status entries
+ */
+function gitStatus(dir) {
+  try {
+    const output = execFileSync('git', ['status', '--porcelain'], {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    if (!output.trim()) {
+      return [];
+    }
+
+    return output.trim().split('\n').map(line => ({
+      status: line.slice(0, 2).trim(),
+      file: line.slice(3)
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create an annotated git tag.
+ * Uses execFileSync to prevent shell injection via tag names or messages.
+ * @param {string} tag - Tag name (e.g., 'v1.0')
+ * @param {string} message - Tag annotation message
+ * @param {string} dir - Working directory
+ * @returns {boolean} true on success
+ */
+function gitTag(tag, message, dir) {
+  try {
+    execFileSync('git', ['tag', '-a', tag, '-m', message], {
+      cwd: dir,
+      stdio: 'pipe'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { isGitRepo, gitInit, gitCommit, gitStatus, gitTag };