J'ai créé un nouveau dépôt Git local:

~$ mkdir projectname
~$ cd projectname
~$ git init
~$ touch file1
~$ git add file1
~$ git commit -m 'first commit'

Existe-t-il une commande git pour créer un nouveau référentiel distant et pousser mon commit sur GitHub à partir d'ici? Je sais que ce n'est pas grave de simplement lancer un navigateur et de créer un nouveau référentiel , mais s'il y a un moyen d'y parvenir à partir de la CLI, je serais heureux.

J'ai lu une grande quantité d'articles mais aucun que j'ai trouvé ne mentionne comment créer un référentiel distant à partir de la CLI en utilisant les commandes git. Bel article de Tim Lucas Mettre en place un nouveau référentiel git distant est le plus proche que j'ai trouvé, mais GitHub ne fournit pas d'accès shell .

Vous pouvez créer un référentiel GitHub via la ligne de commande à l'aide de l'API GitHub. Découvrez l' API du référentiel . Si vous faites défiler vers le bas environ un tiers du chemin, vous verrez une section intitulée "Créer" qui explique comment créer un référentiel via l'API (juste au-dessus, c'est une section qui explique comment créer un référentiel avec l'API, aussi ). Évidemment, vous ne pouvez pas l'utiliser gitpour le faire, mais vous pouvez le faire via la ligne de commande avec un outil comme curl.

En dehors de l'API, il n'y a aucun moyen de créer un dépôt sur GitHub via la ligne de commande. Comme vous l'avez noté, GitHub n'autorise pas l'accès au shell, etc., donc à part l'API GitHub, la seule façon de créer un dépôt est via l'interface Web de GitHub.

Commandes CLI pour github API v3 (remplacer tous les mots clés CAPS):

curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}'
# Remember replace USER with your username and REPO with your repository/application name!
git remote add origin git@github.com:USER/REPO.git
git push origin master

Cela peut être fait avec trois commandes:

curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}'
git remote add origin git@github.com:nyeates/projectname.git
git push origin master

(mis à jour pour l'API Github v3)

Explication de ces commandes ...

Créer un dépôt github

    curl -u 'nyeates' https://api.github.com/user/repos -d '{"name":"projectname","description":"This project is a test"}'

• curl est une commande unix (ci-dessus fonctionne aussi sur mac) qui récupère et interagit avec les URL. Il est généralement déjà installé.
• "-u" est un paramètre curl qui spécifie le nom d'utilisateur et le mot de passe à utiliser pour l'authentification du serveur.
  • Si vous donnez simplement le nom d'utilisateur (comme indiqué dans l'exemple ci-dessus) curl vous demandera un mot de passe.
  • Si vous ne voulez pas avoir à taper le mot de passe, consultez la documentation de l'api githubs sur l' authentification
• "-d" est un paramètre curl qui vous permet d'envoyer des données POST avec la requête
  • Vous envoyez des données POST au format API défini par les githubs
• "nom" est la seule donnée POST requise; J'aime aussi inclure "description"
• J'ai trouvé qu'il était bon de citer toutes les données POST avec des guillemets simples ''

Définir où pousser

git remote add origin git@github.com:nyeates/projectname.git

• ajouter la définition de l'emplacement et de l'existence du dépôt (distant) connecté sur github
• "origine" est un nom par défaut utilisé par git pour savoir d'où vient la source
  • techniquement ne vient pas de github, mais maintenant le repo github sera la source d'enregistrement
• "git@github.com: nyeates" est une connexion ssh qui suppose que vous avez déjà configuré une paire de clés ssh de confiance avec github.

Pousser le dépôt local vers Github

git push origin master

• pousser vers la télécommande d'origine (github) depuis la branche locale principale

Si vous installez l' excellent outil Hub de defunkt , cela devient aussi simple que

git create

Selon les mots de l'auteur, " hub est un wrapper de ligne de commande pour git qui vous rend meilleur chez GitHub. "

Étapes simples (en utilisant git+ hub=> GitHub ):

1. Installez Hub ( GitHub ).

   • OS X: brew install hub
   • avoir Go :go get github.com/github/hub

   • sinon (avoir Go aussi):

     git clone https://github.com/github/hub.git && cd hub && ./script/build
     

2. Accédez à votre prise en pension ou en créer un vide: mkdir foo && cd foo && git init.

3. Exécuter:, hub createil vous posera des questions sur les informations d'identification GitHub pour la première fois.

   Usage: hub create [-p] [-d DESCRIPTION] [-h HOMEPAGE] [NAME]

   Exemple: hub create -d Description -h example.com org_name/foo_repo

   Le hub demandera le nom d'utilisateur et le mot de passe GitHub la première fois qu'il a besoin d'accéder à l'API et de l'échanger contre un OAuthjeton, qu'il enregistre ~/.config/hub.

   Pour nommer explicitement le nouveau référentiel, passez-le NAME, éventuellement sous ORGANIZATION/NAMEforme pour créer sous une organisation dont vous êtes membre.

   Avec -p, créez un référentiel privé, et avec -det -hdéfinissez respectivement la description et la page d'accueil du référentiel URL.

   Pour éviter d'être invité, utilisez GITHUB_USERet GITHUB_PASSWORDvariables d'environnement.

4. Ensuite, validez et appuyez comme d'habitude ou cochez hub commit/ hub push.

Pour plus d' aide, exécutez: hub help.

Voir aussi: Importer un référentiel Git à l'aide de la ligne de commande sur GitHub.

Il y a un joyau github officiel qui, je pense, fait cela. J'essaierai d'ajouter plus d'informations au fur et à mesure que j'apprendrai, mais je ne fais que découvrir ce joyau, donc je ne sais pas encore grand-chose.

MISE À JOUR: Après avoir défini ma clé API, je suis capable de créer un nouveau dépôt sur github via la createcommande, mais je ne suis pas en mesure d'utiliser la create-from-localcommande, qui est censée prendre le dépôt local actuel et faire une télécommande correspondante sur github.

$ gh create-from-local
=> error creating repository

Si quelqu'un a un aperçu de cela, j'aimerais savoir ce que je fais mal. Un problème a déjà été déposé .

MISE À JOUR: J'ai finalement réussi à faire fonctionner cela. Je ne sais pas exactement comment reproduire le problème, mais je viens de recommencer à zéro (suppression du dossier .git)

git init
git add .emacs
git commit -a -m "adding emacs"

Maintenant, cette ligne va créer le référentiel distant et même pousser vers lui, mais malheureusement, je ne pense pas pouvoir spécifier le nom du référentiel que j'aimerais. Je voulais qu'il soit appelé "dotfiles" sur github, mais la gemme gh a juste utilisé le nom du dossier actuel, qui était "jason" puisque j'étais dans mon dossier personnel. (J'ai ajouté un ticket demandant le comportement souhaité)

gh create-from-local

Cette commande, en revanche, accepte un argument pour spécifier le nom du référentiel distant, mais elle est destinée à démarrer un nouveau projet à partir de zéro, c'est-à-dire qu'après avoir appelé cette commande, vous obtenez un nouveau référentiel distant qui suit un référentiel local dans un sous-dossier nouvellement créé par rapport à votre position actuelle, tous deux avec le nom spécifié comme argument.

gh create dotfiles

Pour créer rapidement le référentiel distant à l'aide d'un shell Bash

Il est fastidieux de taper le code complet chaque fois qu'un référentiel doit être créé

curl -u 'USER' https://api.github.com/user/repos -d '{"name":"REPO"}' git remote add origin git@github.com:USER/REPO.git git push origin master

Une approche plus simple consiste à:

1. créer un script shell dans un répertoire ie / home / USER_NAME / Desktop / my_scripts nommé githubscript.sh
2. Modifiez et enregistrez le code suivant dans le githubscript.shfichier
   

#!bin/bash
curl -u 'YOUR_GITHUB_USER_NAME' https://api.github.com/user/repos -d "{\"name\":\"$1\"}";
git init;
git remote add origin git@github.com:YOUR_GITHUB_USER_NAME/$1.git;

NB Voici $1le repository namequi est passé en tant que argumentlors de l'appel de lascript modification YOUR_GITHUB_USER_NAMEavant d'enregistrer le script.

3. Définissez les autorisations requises sur le scriptfichier chmod 755 githubscript.sh

4. Incluez le répertoire des scripts dans le fichier de configuration de l'environnement. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. Définissez également un alias pour exécuter le fichier githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Rechargez maintenant les fichiers .bashrcet .profiledans le terminal. source ~/.bashrc ~/.profile;

7. Maintenant, pour créer un nouveau référentiel, c'est demo-à- dire : githubrepo demo;

Basé sur l'autre réponse de @Mechanical Snail, sauf sans l'utilisation de python, que j'ai trouvé excessivement exagéré. Ajoutez ceci à votre ~/.gitconfig:

[github]
    user = "your-name-here"
[alias]
    hub-new-repo = "!REPO=$(basename $PWD) GHUSER=$(git config --get github.user); curl -u $GHUSER https://api.github.com/user/repos -d {\\\"name\\\":\\\"$REPO\\\"} --fail; git remote add origin git@github.com:$GHUSER/$REPO.git; git push origin master"

Non, vous devez ouvrir un navigateur au moins une fois pour créer votre usernamesur GitHub, une fois créé, vous pouvez utiliser l'API GitHub pour créer des référentiels à partir de la ligne de commande, en suivant la commande ci-dessous:

curl -u 'github-username' https://api.github.com/user/repos -d '{"name":"repo-name"}'

Par exemple:

curl -u 'arpitaggarwal' https://api.github.com/user/repos -d '{"name":"command-line-repo"}'

Pour les utilisateurs avec une authentification à deux facteurs, vous pouvez utiliser la solution de bennedich, mais il vous suffit d'ajouter l'en-tête X-Github-OTP pour la première commande. Remplacez CODE par le code que vous obtenez du fournisseur d'authentification à deux facteurs. Remplacez USER et REPO par le nom d'utilisateur et le nom du référentiel, comme vous le feriez dans sa solution.

curl -u 'USER' -H "X-GitHub-OTP: CODE" -d '{"name":"REPO"}' https://api.github.com/user/repos
git remote add origin git@github.com:USER/REPO.git
git push origin master

J'ai écrit un script astucieux pour cela appelé Gitter utilisant les API REST pour GitHub et BitBucket:

https://github.com/dderiso/gitter

BitBucket:

gitter -c -r b -l javascript -n node_app

GitHub:

gitter -c -r g -l javascript -n node_app

• -c = créer un nouveau référentiel
• -r = fournisseur de référentiel (g = GitHub, b = BitBucket)
• -n = nommez le repo
• -l = (facultatif) définissez la langue de l'application dans le référentiel

J'ai créé un alias Git pour ce faire, basé sur la réponse de Bennedich . Ajoutez ce qui suit à votre ~/.gitconfig:

[github]
    user = "your_github_username"
[alias]
    ; Creates a new Github repo under the account specified by github.user.
    ; The remote repo name is taken from the local repo's directory name.
    ; Note: Referring to the current directory works because Git executes "!" shell commands in the repo root directory.
    hub-new-repo = "!python3 -c 'from subprocess import *; import os; from os.path import *; user = check_output([\"git\", \"config\", \"--get\", \"github.user\"]).decode(\"utf8\").strip(); repo = splitext(basename(os.getcwd()))[0]; check_call([\"curl\", \"-u\", user, \"https://api.github.com/user/repos\", \"-d\", \"{{\\\"name\\\": \\\"{0}\\\"}}\".format(repo), \"--fail\"]); check_call([\"git\", \"remote\", \"add\", \"origin\", \"git@github.com:{0}/{1}.git\".format(user, repo)]); check_call([\"git\", \"push\", \"origin\", \"master\"])'"

Pour l'utiliser, exécutez

$ git hub-new-repo

depuis n'importe où dans le référentiel local et entrez votre mot de passe Github lorsque vous y êtes invité.

Ce dont vous avez besoin, c'est d'un hub . Hub est un wrapper de ligne de commande pour git. Il a été conçu pour s'intégrer à git natif en utilisant un alias. Il essaie de fournir des actions github dans git, y compris la création d'un nouveau référentiel.

→  create a repo for a new project
$ git init
$ git add . && git commit -m "It begins."
$ git create -d "My new thing"
→  (creates a new project on GitHub with the name of current directory)
$ git push origin master

Pour les rubis:

gem install githubrepo
githubrepo create *reponame*

entrez le nom d'utilisateur et pw comme demandé

git remote add origin *ctrl v*
git push origin master

Source: Elikem Adadevoh

Pour tous les utilisateurs de Python 2.7. *. Il existe un wrapper Python autour de l' API Github qui est actuellement sur la version 3, appelé GitPython . Installez simplement en utilisant easy_install PyGithubou pip install PyGithub.

from github import Github
g = Github(your-email-addr, your-passwd)
repo = g.get_user().user.create_repo("your-new-repos-name")

# Make use of Repository object (repo)

Les Repositorydocuments d'objet sont ici .

Pour obtenir des instructions sur la création d'un jeton, cliquez ici. Voici la commande que vous saisirez (à la date de cette réponse. (Remplacez tous les mots clés CAPS):

curl -u 'YOUR_USERNAME' -d '{"scopes":["repo"],"note":"YOUR_NOTE"}' https://api.github.com/authorizations

Une fois que vous avez entré votre mot de passe, vous verrez ce qui suit qui contient votre jeton.

{
  "app": {
    "name": "YOUR_NOTE (API)",
    "url": "http://developer.github.com/v3/oauth/#oauth-authorizations-api"
  },
  "note_url": null,
  "note": "YOUR_NOTE",
  "scopes": [
    "repo"
  ],
  "created_at": "2012-10-04T14:17:20Z",
  "token": "xxxxx",
  "updated_at": "2012-10-04T14:17:20Z",
  "id": xxxxx,
  "url": "https://api.github.com/authorizations/697577"
}

Vous pouvez révoquer votre jeton à tout moment en allant ici

Pour des raisons de représentant, je ne peux pas ajouter ceci en tant que commentaire (où cela irait mieux avec la réponse de Bennedich ), mais pour la ligne de commande Windows, voici la syntaxe correcte:

curl -u YOUR_USERNAME https://api.github.com/user/repos -d "{\" name \ ": \" YOUR_REPO_NAME \ "}"

C'est la même forme de base, mais vous devez utiliser des guillemets doubles (") au lieu de simples, et échapper les guillemets doubles envoyés dans les paramètres POST (après l'indicateur -d) avec des barres obliques inverses. J'ai également supprimé les guillemets simples autour de mon nom d'utilisateur, mais si votre nom d'utilisateur avait un espace (possible?), il aurait probablement besoin de guillemets doubles.

Disclamier: je suis l'auteur du projet open source

Cette fonctionnalité est prise en charge par: https://github.com/chrissound/Human-Friendly-Commands c'est essentiellement ce script:

#!/usr/bin/env bash

# Create a repo named by the current directory
# Accepts 1 STRING parameter for the repo description
# Depends on bin: jq
# Depends on env: GITHUB_USER, GITHUB_API_TOKEN
github_createRepo() {
  projName="$(basename "$PWD")"
  json=$(jq -n \
    --arg name "$projName" \
    --arg description "$1" \
    '{"name":$name, "description":$description}')

  curl -u "$GITHUB_USER":"$GITHUB_API_TOKEN" https://api.github.com/user/repos -d "$json"
  git init
  git remote add origin git@github.com:"$GITHUB_USER"/"$projName".git
  git push origin master
};

J'ai trouvé cette solution qui m'a plu: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Vous devez d'abord créer un jeton d'accès personnel Github

Ouvrez votre ~ / .bash_profile ou ~ / .bashrc dans votre éditeur de texte préféré. Ajoutez la ligne suivante près du haut de votre fichier, où se trouvent les autres variables exportées:

export GITHUB_API_TOKEN=<your-token-here>

Quelque part ci-dessous, par vos autres fonctions bash, vous pouvez coller quelque chose de similaire au suivant:

function new-git() {
    curl -X POST https://api.github.com/user/repos -u <your-username>:$GITHUB_API_TOKEN -d '{"name":"'$1'"}'
}

Désormais, chaque fois que vous créez un nouveau projet, vous pouvez exécuter la commande $ new-git awesome-repopour créer un nouveau référentiel public distant sur votre compte utilisateur Github.

Avec la nouvelle interface de ligne de commande officielle de Github :

gh repo create

Voir les détails et options supplémentaires et les instructions d'installation .

Par exemple, pour terminer votre workflow git:

mkdir project
cd project
git init
touch file
git add file
git commit -m 'Initial commit'
gh repo create
git push -u origin master

voici mes premières commandes git (éventuellement, cette action a lieu dans C:/Documents and Settings/your_username/):

mkdir ~/Hello-World
# Creates a directory for your project called "Hello-World" in your user directory
cd ~/Hello-World
# Changes the current working directory to your newly created directory
touch blabla.html
# create a file, named blabla.html
git init
# Sets up the necessary Git files
git add blabla.html
# Stages your blabla.html file, adding it to the list of files to be committed
git commit -m 'first committttt'
# Commits your files, adding the message 
git remote add origin https://github.com/username/Hello-World.git
# Creates a remote named "origin" pointing at your GitHub repository
git push -u origin master
# Sends your commits in the "master" branch to GitHub

J'ai récemment découvert create-github-repo . Du fichier Lisezmoi:

Installer:

$ npm i -g create-github-repo

Usage:

$ export CREATE_GITHUB_REPO_TOKEN=<access_token>
$ create-github-repo --name "My coolest repo yet!"

Ou:

$ create-github-repo <access_token> --name "My coolest repo yet!"

créer un nouveau référentiel sur la ligne de commande

echo "# <RepositoryName>" >> README.md

git init

git add README.md

git commit -m "first commit"

git remote add origin https://github.com/**<gituserID>/<RepositoryName>**.git

git push -u origin master

pousser un référentiel existant depuis la ligne de commande

git remote add origin https://github.com/**<gituserID>/<RepositoryName>**.git

git push -u origin master