constructor({ config }: { config?: RunOptions } = {}) {
   if (!config) {
     config = {
       mock: false,
     }
   }
   const parentFilename = module.parent!.parent!
     ? module.parent!.parent!.filename
     : module.parent!.filename
   if (!config.initPath) {
     config.initPath = parentFilename
   }
   if (!config.root) {
     const findUp = require('find-up')
     config.root = path.dirname(
       findUp.sync('package.json', {
         cwd: parentFilename,
       }),
     )
   }
   this.config = new Config(config)
   this.notifier = updateNotifier({
     pkg: this.config.pjson,
     updateCheckInterval: 1,
   })
   this.initRaven()
 }

export function resolveRoot(cwd: string, subs: string[]): string | null {
  let home = os.homedir()
  let { root } = path.parse(cwd)
  let p = findUp.sync(subs, { cwd })
  p = p == null ? null : path.dirname(p)
  if (p == null || p == home || p == root) return cwd
  return p
}

export function getRoot() {
  const parentFilename = module.parent!.parent!
    ? module.parent!.parent!.filename
    : module.parent!.filename
  const findUp = require('find-up')
  return path.dirname(
    findUp.sync('package.json', {
      cwd: parentFilename,
    }),
  )
}

export const load = (
  name: string,
  defaultConfig: any = {},
  noCache?: boolean
) => {
  let file = {}
  const filepath = findup.sync(finds(name))

  if (filepath) {
    file = loadFile(filepath, defaultConfig, noCache)
  }

  return defaultConfig !== null ? merge(defaultConfig, file) : file
}

export default function(cwd: string | undefined): string | null {
  const foundPath = findUp.sync('.git', { cwd })

  if (foundPath) {
    const stats = fs.lstatSync(foundPath)

    // If it's a .git file resolve path
    if (stats.isFile()) {
      // Expect following format
      // git: pathToGit
      // On Windows pathToGit can contain ':' (example "gitdir: C:/Some/Path")
      const gitFileData = fs.readFileSync(foundPath, 'utf-8')
      const gitDir = gitFileData
        .split(':')
        .slice(1)
        .join(':')
        .trim()
      const resolvedGitDir = path.resolve(path.dirname(foundPath), gitDir)

      // For git-worktree, check if commondir file exists and return that path
      const pathCommonDir = path.join(resolvedGitDir, 'commondir')
      if (fs.existsSync(pathCommonDir)) {
        const commondir = fs.readFileSync(pathCommonDir, 'utf-8').trim()
        const resolvedCommonGitDir = path.join(resolvedGitDir, commondir)
        return resolvedCommonGitDir
      }

      return resolvedGitDir
    }

    // Else return path to .git directory
    return foundPath
  }

  return null
}

#!/usr/bin/env node

import '@babel/register';
import findUp from 'find-up';
import start, { StartOptions } from './scripts/start';
import build, { BuildOptions } from './scripts/build';

require('yargs') // eslint-disable-line
  .command(
    'start',
    'Start webpack dev server',
    () => {},
    (argv: StartOptions) => {
      start(argv);
    }
  )
  .command(
    'build',
    'Build application',
    () => {},
    (argv: BuildOptions) => {
      build(argv);
    }
  )
  .option('config', {
    alias: 'c',
    default: findUp.sync('medpack.js'),
  }).argv;

export function install(
  huskyDir: string,
  requireRunNodePath: string = require.resolve('run-node/run-node'),
  isCI: boolean
): void {
  console.log('husky > Setting up git hooks')

  // First directory containing user's package.json
  const userPkgDir = pkgDir.sync(path.join(huskyDir, '..'))

  if (userPkgDir === undefined) {
    console.log("Can't find package.json, skipping Git hooks installation.")
    console.log(
      'Please check that your project has a package.json or create it and reinstall husky.'
    )
    return
  }

  // Get conf from package.json or .huskyrc
  const conf = getConf(userPkgDir)
  // Get directory containing .git directory or in the case of Git submodules, the .git file
  const gitDirOrFile = findUp.sync('.git', { cwd: userPkgDir })
  // Resolve git directory (e.g. .git/ or .git/modules/path/to/submodule)
  const resolvedGitDir = resolveGitDir(userPkgDir)

  // Checks
  if (process.env.HUSKY_SKIP_INSTALL === 'true') {
    console.log(
      "HUSKY_SKIP_INSTALL environment variable is set to 'true',",
      'skipping Git hooks installation.'
    )
    return
  }

  if (gitDirOrFile === null || gitDirOrFile === undefined) {
    console.log("Can't find .git, skipping Git hooks installation.")
    console.log(
      "Please check that you're in a cloned repository",
      "or run 'git init' to create an empty Git repository and reinstall husky."
    )
    return
  }

  if (resolvedGitDir === null) {
    console.log(
      "Can't find resolved .git directory, skipping Git hooks installation."
    )
    return
  }

  if (isCI && conf.skipCI) {
    console.log('CI detected, skipping Git hooks installation.')
    return
  }

  if (isInNodeModules(huskyDir)) {
    console.log(
      'Trying to install from node_modules directory, skipping Git hooks installation.'
    )
    return
  }

  // Create hooks directory if doesn't exist
  if (!fs.existsSync(path.join(resolvedGitDir, 'hooks'))) {
    fs.mkdirSync(path.join(resolvedGitDir, 'hooks'))
  }

  // Create hooks
  // Get root dir based on the first .git directory of file found
  const rootDir = path.dirname(gitDirOrFile)

  const hooks = getHooks(resolvedGitDir)
  const script = getScript(rootDir, huskyDir, requireRunNodePath)
  createHooks(hooks, script)

  console.log(`husky > Done`)
  console.log('husky > Like husky? You can support the project on Patreon:')
  console.log(
    'husky > \x1b[36m%s\x1b[0m 🐕',
    'https://www.patreon.com/typicode'
  )
}