Ho creato un nuovo repository Git locale:

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

Esiste un comando git per creare un nuovo repository remoto e spingere il mio commit su GitHub da qui? So che non è un grosso problema accendere un browser e andare a creare un nuovo repository , ma se c'è un modo per ottenere questo risultato dalla CLI sarei felice.

Ho letto una grande quantità di articoli, ma nessuno di quelli che ho trovato menziona come creare un repository remoto dalla CLI usando i comandi git. Il bell'articolo di Tim Lucas Configurare un nuovo repository git remoto è il più vicino che ho trovato, ma GitHub non fornisce l'accesso alla shell .

È possibile creare un repository GitHub tramite la riga di comando utilizzando l'API GitHub. Controlla l' API del repository . Se scorri verso il basso per circa un terzo, vedrai una sezione intitolata "Crea" che spiega come creare un repository tramite l'API (proprio sopra quella è una sezione che spiega come eseguire il fork di un repository anche con l'API ). Ovviamente non puoi usarlo gitper farlo, ma puoi farlo tramite la riga di comando con uno strumento simile curl.

Al di fuori dell'API, non è possibile creare un repository su GitHub tramite la riga di comando. Come hai notato, GitHub non consente l'accesso alla shell, ecc., Quindi a parte l'API GitHub, l'unico modo per creare un repository è tramite l'interfaccia web di GitHub.

Comandi CLI per github API v3 (sostituisci tutte le parole chiave 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

Questo può essere fatto con tre comandi:

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

(aggiornato per l'API Github v3)

Spiegazione di questi comandi ...

Crea repository github

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

• curl è un comando unix (sopra funziona anche su Mac) che recupera e interagisce con gli URL. È comunemente già installato.
• "-u" è un parametro di arricciatura che specifica il nome utente e la password da utilizzare per l'autenticazione del server.
  • Se si fornisce semplicemente il nome utente (come mostrato nell'esempio sopra), curl richiederà una password.
  • Se non si desidera digitare la password, consultare la documentazione di githubs api su Autenticazione
• "-d" è un parametro di arricciatura che consente di inviare dati POST con la richiesta
  • Stai inviando dati POST in formato API definito githubs
• "name" è l'unico dato POST richiesto; Mi piace includere anche la "descrizione"
• Ho scoperto che era bello citare tutti i dati POST con virgolette singole ''

Definisci dove spingere

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

• aggiungere la definizione per posizione ed esistenza del repository (remoto) connesso su github
• "origine" è un nome predefinito usato da git per la provenienza della fonte
  • tecnicamente non proviene da Github, ma ora il repository Github sarà la fonte di record
• "git@github.com: nyeates" è una connessione ssh che presuppone che tu abbia già configurato una coppia di chiavi ssh attendibile con github.

Invia repo locale a github

git push origin master

• spingere sul telecomando di origine (github) dal ramo locale principale

Se installi l' eccellente strumento Hub di defunkt , questo diventa facile come

git create

Nelle parole dell'autore, " hub è un wrapper da riga di comando per git che ti rende migliore in GitHub " .

Semplici passaggi (usando git+ hub=> GitHub ):

1. Installa Hub ( GitHub ).

   • OS X: brew install hub
   • avendo andare :go get github.com/github/hub

   • altrimenti (avendo anche Go ):

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

2. Vai al tuo repo o crearne uno vuoto: mkdir foo && cd foo && git init.

3. Esegui: hub createti chiederà per la prima volta le credenziali di GitHub.

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

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

   Hub richiederà nome utente e password GitHub la prima volta che deve accedere all'API e scambiarlo con un OAuthtoken, in cui salva~/.config/hub .

   Per assegnare un nome esplicito al nuovo repository, passare NAME, facoltativamente inORGANIZATION/NAME modulo da creare in un'organizzazione di cui sei membro.

   Con -p, creare un repository privato e con -de -himpostare la descrizione e la homepage del repositoryURL .

   Per evitare di essere richiesto, utilizzare GITHUB_USERe GITHUB_PASSWORDvariabili di ambiente.

4. Quindi eseguire il commit e premere come al solito o selezionare hub commit/ hub push.

Per ulteriori informazioni, esegui: hub help .

Vedi anche: Importare un repository Git usando la riga di comando su GitHub.

C'è una gemma ufficiale di github che, penso, lo fa. Cercherò di aggiungere ulteriori informazioni mentre imparo, ma sto scoprendo solo ora questo gioiello, quindi non so ancora molto.

AGGIORNAMENTO: Dopo aver impostato la mia chiave API, sono in grado di creare un nuovo repository su github tramite il createcomando, tuttavia non sono in grado di utilizzare il create-from-localcomando, che dovrebbe prendere l'attuale repository locale e creare un corrispondente remote out su github.

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

Se qualcuno ha qualche idea su questo, mi piacerebbe sapere cosa sto facendo di sbagliato. C'è già un problema archiviato .

AGGIORNAMENTO: Alla fine l'ho fatto funzionare. Non sono esattamente sicuro di come riprodurre nuovamente il problema, ma ho appena iniziato da zero (eliminato la cartella .git)

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

Ora questa linea creerà il repository remoto e persino spingerà ad esso, ma sfortunatamente non penso di poter specificare il nome del repository che mi piacerebbe. Volevo che si chiamasse "dotfile" su github, ma la gemma gh ha appena usato il nome della cartella corrente, che era "jason" da quando ero nella mia cartella home. (Ho aggiunto un biglietto per chiedere il comportamento desiderato)

gh create-from-local

Questo comando, d'altra parte, accetta un argomento per specificare il nome del repository remoto, ma è pensato per avviare un nuovo progetto da zero, ovvero dopo aver chiamato questo comando, si ottiene un nuovo repository remoto che tiene traccia di un repository locale in una sottocartella di nuova creazione relativa alla posizione corrente, entrambi con il nome specificato come argomento.

gh create dotfiles

Creare rapidamente il repository remoto usando una shell Bash

È scomodo digitare il codice completo ogni volta che si crea un repository

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

Un approccio più semplice è:

1. creare uno script shell in una directory, ad esempio / home / USER_NAME / Desktop / my_scripts denominato githubscript.sh
2. Modifica e salva il seguente codice nel githubscript.shfile
   

#!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 Ecco $1quello repository nameche viene passato come argumentquando si richiama lascript modifica YOUR_GITHUB_USER_NAMEprima di salvare lo script.

3. Imposta le autorizzazioni necessarie per il scriptfile chmod 755 githubscript.sh

4. Includere la directory degli script nel file di configurazione dell'ambiente. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. Imposta anche un alias per eseguire il file githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Ora ricaricare i file .bashrce .profilenel terminale. source ~/.bashrc ~/.profile;

7. Ora per creare un nuovo repository cioè demo: githubrepo demo;

Basato sull'altra risposta di @Mechanical Snail, tranne che senza l'uso di Python, che ho scoperto essere eccessivamente selvaggio. Aggiungi questo al tuo ~/.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"

No, devi aprire almeno un browser per crearne uno usernamesu GitHub, una volta creato, puoi sfruttare l' API GitHub per creare repository dalla riga di comando, seguendo il comando seguente:

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

Per esempio:

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

Per gli utenti con autenticazione a due fattori, è possibile utilizzare la soluzione di bennedich, ma è sufficiente aggiungere l'intestazione X-Github-OTP per il primo comando. Sostituisci CODE con il codice che ottieni dal provider di autenticazione a due fattori. Sostituisci USER e REPO con il nome utente e il nome del repository, come faresti con la sua soluzione.

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

Ho scritto una sceneggiatura elegante per questo chiamato Gitter usando le API REST per GitHub e 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 = crea nuovo repository
• -r = provider di pronti contro termine (g = GitHub, b = BitBucket)
• -n = nome del repository
• -l = (facoltativo) imposta la lingua dell'app nel repository

Ho creato un alias Git per farlo, basato sulla risposta di Bennedich . Aggiungi quanto segue al tuo ~/.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\"])'"

Per usarlo, esegui

$ git hub-new-repo

da qualsiasi punto all'interno del repository locale e inserisci la tua password Github quando richiesto.

Quello di cui hai bisogno è un hub . Hub è un wrapper a riga di comando per git. È stato creato per integrarsi con git nativo usando l'alias. Prova a fornire azioni github in git inclusa la creazione di un nuovo repository.

→  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

Per i rubini:

gem install githubrepo
githubrepo create *reponame*

inserisci username e pw come richiesto

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

Fonte: Elikem Adadevoh

Per tutti gli utenti di Python 2.7. *. C'è un wrapper Python attorno all'API Github che è attualmente nella versione 3, chiamato GitPython . Installa semplicemente usando easy_install PyGithubo 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)

I Repositorydocumenti oggetto sono qui .

Per indicazioni sulla creazione di un token, vai qui Questo è il comando che digiterai (alla data di questa risposta. (Sostituisci tutte le parole chiave CAPS):

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

Dopo aver inserito la password, verrà visualizzato quanto segue che contiene il 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"
}

Puoi revocare il tuo token in qualsiasi momento andando qui

Per ragioni di rappresentante, non posso aggiungere questo come commento (dove sarebbe meglio andare con la risposta di Bennedich ), ma per la riga di comando di Windows, ecco la sintassi corretta:

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

È la stessa forma di base, ma devi usare le virgolette doppie (") anziché singole e sfuggire alle doppie virgolette inviate nei parametri POST (dopo il flag -d) con barre rovesciate. Ho anche rimosso le virgolette singole attorno al mio nome utente, ma se il tuo nome utente avesse uno spazio (possibile?) probabilmente avrebbe bisogno di doppie virgolette.

Disclamier: sono l'autore del progetto open source

Questa funzionalità è supportata da: https://github.com/chrissound/Human-Friendly-Commands essenzialmente è questo 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
};

Ho trovato questa soluzione che mi è piaciuta: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Devi prima creare un token di accesso personale Github

Apri il tuo ~ / .bash_profile o ~ / .bashrc nel tuo editor di testo preferito. Aggiungi la seguente riga nella parte superiore del file, dove sono le altre variabili esportate:

export GITHUB_API_TOKEN=<your-token-here>

Da qualche parte in basso, con le altre tue funzioni bash, puoi incollare qualcosa di simile al seguente:

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

Ora, ogni volta che stai creando un nuovo progetto, puoi eseguire il comando $ new-git awesome-repoper creare un nuovo repository remoto pubblico sul tuo account utente Github.

Con la nuova interfaccia ufficiale della riga di comando di Github :

gh repo create

Vedi ulteriori dettagli e opzioni e istruzioni di installazione .

Ad esempio, per completare il flusso di lavoro 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

ecco i miei comandi git iniziali (possibilmente, questa azione si svolge in 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

Di recente ho scoperto di creare-github-repo . Dal readme:

Installare:

$ npm i -g create-github-repo

Uso:

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

O:

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

creare un nuovo repository sulla riga di comando

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

invia un repository esistente dalla riga di comando

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

git push -u origin master