CLI commandes for github API v3 (replace all CAPS keywords):

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

(mise à jour pour L'API v3 Github)

Explication de ces commandes...

créer GitHub repo

    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 URLs. Il est généralement déjà installé.
• " - u" est un curl paramètre qui spécifie le nom d'utilisateur et mot de passe à utiliser pour l'authentification du serveur.
  • si vous donnez simplement le nom d'utilisateur (comme montré dans l'exemple ci-dessus) curl demandera un mot de passe.
  • si vous ne voulez pas avoir à taper le mot de passe, consultez la documentation de l'api githubs sur authentification
• " - d" est un paramètre curl qui vous permet d'envoyer des données POST avec le demande
  • vous envoyez des données postales en githubs format API défini
• "nom" est le seul POST données requises; j'aime aussi inclure "description"
• j'ai trouvé qu'il était bon de les citer toutes les données POST avec des guillemets simples ''

Définir le pousser à

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

• ajouter la définition de localisation et existence de la prise en pension (à distance) connectée sur github
• "origine" est un nom par défaut utilisé par git pour le cas où la source est venu de
  • techniquement ne vient pas de github, mais maintenant le GitHub repo sera la source de l'enregistrement
• "git@github.com:nyeates" est une connexion ssh qui suppose que vous avez déjà configuré un clavier SSH de confiance avec github.

Push local repo à github

git push origin master

• pousser à l'origine de la télécommande (github) à partir de le maître de la succursale locale

si vous installez defunkt's excellent Hub outil, alors cela devient aussi facile que

git create

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

étapes Simples (à l'aide de git + hub => GitHub ):

1. Install Hub ( GitHub ).

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

   • autrement (ayant Go ainsi):

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

2. allez à votre dossier ou créez un dossier vide: mkdir foo && cd foo && git init .

3. Run: hub create , il vous posera des questions sur les références GitHub pour la première fois.

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

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

   Hub demandera pour GitHub nom d'utilisateur et mot de passe la première fois qu'il a besoin de accédez à L'API et échangez-la contre un token OAuth , qu'elle sauvegarde dans ~/.config/hub .

   pour nommer explicitement le nouveau dépôt, passez à NAME , optionnellement dans le formulaire ORGANIZATION/NAME pour créer sous une organisation vous êtes un membre de.

   avec -p , créer un dépôt privé, et avec -d et -h établissent la description du dépôt et la page d'accueil URL , respectivement.

   Pour éviter d'être invité, utilisez GITHUB_USER et GITHUB_PASSWORD variables d'environnement.

4. Puis commit et push comme d'habitude ou cochez la case hub commit / hub push .

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

Voir aussi: Importer un dépôt Git en utilisant la ligne de commande à GitHub.

il y a un GitHub gem officiel qui, je pense, fait ceci. Je vais essayer d'ajouter plus d'informations à mesure que j'apprends, mais je viens juste de découvrir ce joyau, donc je ne sais pas encore grand chose.

mise à jour: après avoir paramétré ma clé API, je suis capable de créer un nouveau repo sur github via la commande create , cependant je ne suis pas capable d'utiliser la commande create-from-local , qui est censée prendre le repo local actuel et faire une télécommande correspondante sur github.

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

si quelqu'un a une idée là-dessus, j'aimerais savoir ce que je fais de mal. Il y a déjà un numéro déposé .

mise à JOUR: j'ai fini par obtenir que cela fonctionne. Je ne sais pas exactement comment reproduire le problème, mais je viens de commencer à partir de zéro (supprimé le .git dossier)

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

maintenant cette ligne va créer le repo à distance et même pousser à elle, mais malheureusement je ne pense pas que je peux spécifiez le nom du repo que j'aimerais. Je voulais qu'il s'appelle "dotfiles" sur github, mais le gemme gh vient d'utiliser le nom du dossier courant, qui était "jason" depuis que j'étais dans mon dossier personnel. (J'ai ajouté un billet demandant le comportement désiré)

gh create-from-local

cette commande, d'un autre côté, accepte un argument pour spécifier le nom du repo distant, mais il est destiné à démarrer un nouveau projet à partir de zéro, c.-à-d. après que vous l'appelez commande, vous obtenez un nouveau repo distant qui suit un repo local dans un sous-dossier nouvellement créé par rapport à votre position actuelle, les deux avec le nom spécifié comme argument.

gh create dotfiles

pour créer rapidement le dépôt distant en utilisant un Shell Bash

il est difficile de taper le code complet chaque fois qu'un dépôt 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 facile est:

1. créez un script shell dans un répertoire i.e. /home/USER_NAME/Desktop/my_scripts named githubscript.sh
2. Modifier et sauvegarder le code suivant githubscript.sh fichier
   
   

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

N.B. ici est le repository name qui est passé comme un argument en invoquant le script Changez YOUR_GITHUB_USER_NAME avant de sauvegarder le script.

3. définissez les permissions requises au fichier script chmod 755 githubscript.sh

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

5. a également défini un alias pour exécuter le githubscript.sh file. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. rechargez maintenant les fichiers .bashrc et .profile dans le terminal. source ~/.bashrc ~/.profile;

7. maintenant pour créer un nouveau dépôt c.-à-d. demo : githubrepo demo;

pour les utilisateurs avec authentification à deux facteurs, vous pouvez utiliser la solution de bennedich, mais vous avez juste besoin d'ajouter L'en-tête X-Github-OTP pour la première commande. Remplacez le 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 dépôt, 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 en utilisant le reste APIs 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 repo
• -r = fournisseur de pensions (g = Github, B = BitBucket)
• -n = Nom the repo
• -l = (optionnel) définir la langue de l'application dans le repo

j'ai créé un alias Git pour ce faire, basé sur réponse de Bennedich . Ajouter 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, Lancez

$ git hub-new-repo

à partir de n'importe où dans le dépôt local, et entrez votre mot de passe GitHub lorsque demandé.

Pour Rubyists:

gem install githubrepo
githubrepo create *reponame*

entrer le nom d'utilisateur et pw comme indiqué

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

Source: Elikem Adadevoh

basé sur l'autre réponse de @Mechanical Snail, sauf sans l'utilisation de python, que j'ai trouvé être sauvagement 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 username sur GitHub, une fois créé, vous pouvez utiliser API GitHub pour créer des dépôts à 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 instructions sur la création d'un token, allez ici c'est la commande que vous taperez (à partir de la date de cette réponse. (remplacer 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 aurez entré votre mot de passe, vous verrez ce qui suit qui contient votre token.

{
  "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 token à tout moment en allant ici

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

→  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 des raisons de rep, Je ne peux pas ajouter ceci comme un commentaire( où il vaudrait mieux aller avec réponse de bennedich ), mais pour la ligne de commande de 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 aux guillemets doubles envoyés dans le POST paramètres (après le drapeau-d) avec antislashs. J'ai aussi supprimé les guillemets autour de mon nom d'utilisateur, mais si votre nom d'utilisateur avait un espace (possible?) il serait probablement besoin de guillemets doubles.

pour tout le Python 2.7.* utilisateur. Il existe un enveloppeur Python autour de l'API Github qui est actuellement sur la Version 3, appelé GitPython . Installez simplement en utilisant easy_install PyGithub ou 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)

le Repository objet docs sont ici .

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

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

Ouvrez votre ~/.bash_profile ou ~/.bashrc dans votre éditeur de texte favori. Ajoutez la ligne suivante près du haut de votre fichier, où le reste des variables ed d'exportation sont:

export GITHUB_API_TOKEN=<your-token-here>

quelque part ci-dessous, par vos autres fonctions bash, vous pouvez coller quelque chose similaire à ce qui suit:

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

maintenant, à chaque fois que vous créez un nouveau projet, vous pouvez exécuter la commande $ new-git awesome-repo pour créer un nouveau dépôt public distant sur votre compte utilisateur Github.

Disclamier: je suis l'auteur du projet open source

cette fonctionnalité est supportée par: https://github.com/chrissound/LinuxVerboseCommandLib 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 "" \
    '{"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
};

voici mes commandes initiales git (peut-être, 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 au sujet de créer-GitHub-repo . Extrait du readme:

Installation:

$ npm i -g create-github-repo

Utilisation:

$ 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 dépôt en 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

poussez un dépôt existant à partir de la ligne de commande

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

git push -u origin master