Ich habe ein neues lokales Git-Repository erstellt:

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

Gibt es einen git-Befehl, um ein neues Remote- Repo zu erstellen und mein Commit von hier aus an GitHub zu senden? Ich weiß, dass es keine große Sache ist, einfach einen Browser zu starten und ein neues Repository zu erstellen , aber wenn es eine Möglichkeit gibt, dies über die CLI zu erreichen, würde ich mich freuen.

Ich habe eine große Anzahl von Artikeln gelesen, aber keiner, den ich gefunden habe, erwähnt, wie ein Remote-Repo aus der CLI mit Git-Befehlen erstellt wird. Tim Lucas 'netter Artikel Das Einrichten eines neuen Remote-Git-Repositorys ist der nächste, den ich gefunden habe, aber GitHub bietet keinen Shell-Zugriff .

Sie können ein GitHub-Repo über die Befehlszeile mithilfe der GitHub-API erstellen. Überprüfen Sie die Repository-API . Wenn Sie etwa ein Drittel des Weges nach unten scrollen, wird ein Abschnitt mit dem Titel "Erstellen" angezeigt , in dem erläutert wird, wie ein Repo über die API erstellt wird (rechts darüber befindet sich ein Abschnitt, in dem auch erläutert wird, wie ein Repo mit der API gegabelt wird ). Natürlich können Sie dies nicht verwenden git, aber Sie können es über die Befehlszeile mit einem Tool wie tun curl.

Außerhalb der API gibt es keine Möglichkeit, ein Repo auf GitHub über die Befehlszeile zu erstellen. Wie Sie bereits bemerkt haben, erlaubt GitHub keinen Shell-Zugriff usw. Abgesehen von der GitHub-API können Sie ein Repo nur über die Webschnittstelle von GitHub erstellen.

CLI-Befehle für die Github-API v3 (ersetzen Sie alle CAPS-Schlüsselwörter):

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

Dies kann mit drei Befehlen erfolgen:

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

(aktualisiert für v3 Github API)

Erklärung dieser Befehle ...

Erstellen Sie ein Github-Repo

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

• curl ist ein Unix-Befehl (oben funktioniert auch auf Mac), der URLs abruft und mit ihnen interagiert. Es ist in der Regel bereits installiert.
• "-u" ist ein Curl-Parameter, der den Benutzernamen und das Kennwort angibt, die für die Serverauthentifizierung verwendet werden sollen.
  • Wenn Sie nur den Benutzernamen angeben (wie im obigen Beispiel gezeigt), fordert curl zur Eingabe eines Kennworts auf.
  • Wenn Sie das Kennwort nicht eingeben müssen, lesen Sie die Dokumentation zur githubs-API zur Authentifizierung
• "-d" ist ein Curl-Parameter, mit dem Sie POST-Daten mit der Anforderung senden können
  • Sie senden POST-Daten im von Githubs definierten API-Format
• "Name" sind die einzigen erforderlichen POST-Daten. Ich möchte auch "Beschreibung" hinzufügen
• Ich fand es gut, alle POST-Daten in einfache Anführungszeichen zu setzen ''

Definieren Sie, wohin Sie drücken möchten

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

• Definition für Ort und Existenz des verbundenen (Remote-) Repos auf Github hinzufügen
• "origin" ist ein Standardname, der von git verwendet wird, woher die Quelle stammt
  • Technisch gesehen kam es nicht von Github, aber jetzt wird das Github-Repo die Quelle der Aufzeichnung sein
• "git@github.com: nyeates" ist eine SSH-Verbindung, bei der davon ausgegangen wird, dass Sie bereits ein vertrauenswürdiges SSH-Schlüsselpaar mit Github eingerichtet haben.

Schieben Sie das lokale Repo auf Github

git push origin master

• Push zur Ursprungsfernbedienung (Github) vom lokalen Master-Zweig

Wenn Sie das hervorragende Hub- Tool von defunkt installieren , ist dies so einfach wie möglich

git create

Mit den Worten des Autors: " Hub ist ein Befehlszeilen-Wrapper für Git, der Sie bei GitHub besser macht. "

Einfache Schritte (mit git+ hub=> GitHub ):

1. Installieren Sie Hub ( GitHub ).

   • OS X: brew install hub
   • mit gehen :go get github.com/github/hub

   • ansonsten (auch mit Go ):

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

2. Gehen Sie zu Ihrem Repo oder erstellen Sie ein leeres : mkdir foo && cd foo && git init.

3. Führen Sie : hub create, Sie werden zum ersten Mal nach GitHub-Anmeldeinformationen gefragt.

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

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

   Hub fordert beim ersten Zugriff auf die API zur Eingabe des GitHub-Benutzernamens und -Kennworts auf und tauscht sie gegen ein OAuthToken aus, das gespeichert wird~/.config/hub .

   Um das neue Repository explizit zu benennen, übergeben Sie es NAME, optional in ORGANIZATION/NAMEForm, um es unter einer Organisation zu erstellen, der Sie angehören.

   -pErstellen Sie mit , erstellen Sie ein privates Repository -dund -hlegen Sie die Beschreibung und die Homepage des Repositorys fest URL.

   Werden aufgefordert, die Verwendung zu vermeiden GITHUB_USERund GITHUB_PASSWORDUmgebungsvariablen.

4. Dann festschreiben und wie gewohnt drücken oder hub commit/ prüfen hub push.

Weitere Hilfe erhalten Sie unter : hub help.

Siehe auch: Importieren eines Git-Repositorys über die Befehlszeile von GitHub.

Es gibt einen offiziellen Github-Edelstein , der dies meiner Meinung nach tut. Ich werde versuchen, weitere Informationen hinzuzufügen, während ich lerne, aber ich entdecke dieses Juwel erst jetzt, daher weiß ich noch nicht viel.

UPDATE: Nachdem ich meinen API-Schlüssel festgelegt habe, kann ich über das ein neues Repo auf Github erstellen create Befehl Ich kann jedoch nicht den create-from-localBefehl verwenden, der das aktuelle lokale Repo übernehmen und eine entsprechende Fernbedienung auf Github erstellen soll.

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

Wenn jemand einen Einblick in diese Sache hat, würde ich gerne wissen, was ich falsch mache. Es wurde bereits ein Problem eingereicht .

UPDATE: Ich habe das irgendwann zum Laufen gebracht. Ich bin mir nicht ganz sicher, wie ich das Problem reproduzieren soll, aber ich habe gerade von vorne angefangen (den .git-Ordner gelöscht).

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

Jetzt wird diese Zeile das Remote-Repo erstellen und sogar darauf drücken, aber leider glaube ich nicht, dass ich den Namen des Repos angeben kann, das ich möchte. Ich wollte, dass es auf Github "Dotfiles" heißt, aber das Gh-Juwel verwendete nur den Namen des aktuellen Ordners, der "Jason" war, da ich mich in meinem Home-Ordner befand. (Ich habe ein Ticket hinzugefügt , das nach dem gewünschten Verhalten fragt.)

gh create-from-local

Dieser Befehl akzeptiert andererseits ein Argument, um den Namen des Remote-Repos anzugeben. Er dient jedoch dazu, ein neues Projekt von Grund auf neu zu starten. Wenn Sie diesen Befehl aufrufen, erhalten Sie ein neues Remote-Repo, das ein lokales Repo verfolgt in einem neu erstellten Unterordner relativ zu Ihrer aktuellen Position, beide mit dem als Argument angegebenen Namen.

gh create dotfiles

So erstellen Sie schnell das Remote-Repository mithilfe einer Bash-Shell

Es ist umständlich, jedes Mal, wenn ein Repository erstellt werden soll, den vollständigen Code einzugeben

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

Ein einfacher Ansatz ist:

1. Erstellen Sie ein Shell-Skript in einem Verzeichnis mit dem Namen / home / USER_NAME / Desktop / my_scripts githubscript.sh
2. Ändern Sie den folgenden Code und speichern Sie ihn in der githubscript.shDatei
   

#!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 Hier $1ist die repository name, die argumentbeim Aufrufen derscript Änderung YOUR_GITHUB_USER_NAMEvor dem Speichern des Skripts übergeben wird.

3. Legen Sie die erforderlichen Berechtigungen für die scriptDatei fest chmod 755 githubscript.sh

4. Fügen Sie das Skriptverzeichnis in die Umgebungskonfigurationsdatei ein. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. Legen Sie außerdem einen Alias ​​fest, um die Datei githubscript.sh auszuführen. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Laden Sie nun die .bashrcund .profile-Dateien im Terminal neu. source ~/.bashrc ~/.profile;

7. Nun erstellen Sie ein neues Repository, dh demo: githubrepo demo;

Basierend auf der anderen Antwort von @Mechanical Snail, außer ohne die Verwendung von Python, was ich als wild übertrieben empfand. Fügen Sie dies zu Ihrem hinzu ~/.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"

Nein, Sie müssen mindestens einmal einen Browser öffnen, um Ihren usernameauf GitHub zu erstellen . Sobald er erstellt wurde, können Sie die GitHub-API nutzen , um Repositorys über die Befehlszeile zu erstellen. Befolgen Sie dazu den folgenden Befehl:

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

Zum Beispiel:

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

Für Benutzer mit Zwei-Faktor-Authentifizierung können Sie die bennedich-Lösung verwenden, müssen jedoch nur den X-Github-OTP-Header für den ersten Befehl hinzufügen. Ersetzen Sie CODE durch den Code, den Sie vom Zwei-Faktor-Authentifizierungsanbieter erhalten. Ersetzen Sie USER und REPO durch den Benutzernamen und den Namen des Repositorys, wie Sie es in seiner Lösung tun würden.

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

Ich habe dafür ein geschicktes Skript namens Gitter geschrieben , das die REST-APIs für GitHub und BitBucket verwendet:

https://github.com/dderiso/gitter

Bit Bucket:

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

GitHub:

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

• -c = neues Repo erstellen
• -r = Repo-Anbieter (g = GitHub, b = BitBucket)
• -n = Benennen Sie das Repo
• -l = (optional) Legt die Sprache der App im Repo fest

Ich habe dafür einen Git-Alias ​​erstellt, basierend auf Bennedichs Antwort . Fügen Sie Folgendes hinzu ~/.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\"])'"

Führen Sie es aus, um es zu verwenden

$ git hub-new-repo

Geben Sie von überall im lokalen Repository aus Ihr Github-Passwort ein, wenn Sie dazu aufgefordert werden.

Was Sie brauchen, ist Hub . Hub ist ein Befehlszeilen-Wrapper für Git. Es wurde entwickelt, um mithilfe von Alias ​​in natives Git zu integrieren. Es wird versucht, Github-Aktionen in Git bereitzustellen, einschließlich der Erstellung eines neuen Repositorys.

→  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

Für Rubyisten:

gem install githubrepo
githubrepo create *reponame*

Geben Sie den Benutzernamen und pw ein, wenn Sie dazu aufgefordert werden

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

Quelle: Elikem Adadevoh

Für alle Python 2.7. * Benutzer. Es gibt einen Python-Wrapper um die Github-API , der derzeit auf Version 3 ist und GitPython heißt . Einfach mit easy_install PyGithuboder installieren 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)

Die RepositoryObjektdokumente sind hier .

Anweisungen zum Erstellen eines Tokens finden Sie hier. Dies ist der Befehl, den Sie eingeben werden (ab dem Datum dieser Antwort. (Alle CAPS-Schlüsselwörter ersetzen):

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

Sobald Sie Ihr Passwort eingegeben haben, sehen Sie Folgendes, das Ihr Token enthält.

{
  "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"
}

Sie können Ihren Token jederzeit widerrufen, indem Sie hier klicken

Aus Wiederholungsgründen kann ich dies nicht als Kommentar hinzufügen (wo es besser zu Bennedichs Antwort passt ), aber für die Windows-Befehlszeile ist hier die richtige Syntax:

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

Es ist dieselbe Grundform, aber Sie müssen doppelte Anführungszeichen (") anstelle von einfachen Anführungszeichen verwenden und die doppelten Anführungszeichen, die in den POST-Parametern (nach dem Flag -d) gesendet werden, mit umgekehrten Schrägstrichen umgehen. Ich habe auch die einfachen Anführungszeichen um meinen Benutzernamen entfernt. aber wenn Ihr Benutzername ein Leerzeichen hätte (möglich?), würde er wahrscheinlich doppelte Anführungszeichen benötigen.

Disclamier: Ich bin der Autor des Open Source-Projekts

Diese Funktionalität wird unterstützt von: https://github.com/chrissound/Human-Friendly-Commands Im Wesentlichen handelt es sich um dieses Skript:

#!/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
};

Ich habe diese Lösung gefunden, die mir gefallen hat: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Sie müssen zuerst ein persönliches Github-Zugriffstoken erstellen

Öffnen Sie Ihr ~ / .bash_profile oder ~ / .bashrc in Ihrem bevorzugten Texteditor. Fügen Sie die folgende Zeile am oberen Rand Ihrer Datei hinzu, in der sich die restlichen exportierten Variablen befinden:

export GITHUB_API_TOKEN=<your-token-here>

Irgendwo unten können Sie mit Ihren anderen Bash-Funktionen etwas Ähnliches wie das Folgende einfügen:

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

Wenn Sie jetzt ein neues Projekt $ new-git awesome-repoerstellen , können Sie den Befehl ausführen , um ein neues öffentliches Remote-Repository in Ihrem Github-Benutzerkonto zu erstellen.

Mit der offiziellen neuen Befehlszeilenschnittstelle von Github :

gh repo create

Weitere Details und Optionen sowie Installationsanweisungen finden Sie hier .

So vervollständigen Sie beispielsweise Ihren Git-Workflow:

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

Hier sind meine ersten Git-Befehle (möglicherweise findet diese Aktion in statt 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

Ich habe kürzlich von create-github-repo erfahren . Aus der Readme:

Installieren:

$ npm i -g create-github-repo

Verwendungszweck:

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

Oder:

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

Erstellen Sie ein neues Repository in der Befehlszeile

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

Verschieben Sie ein vorhandenes Repository über die Befehlszeile

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

git push -u origin master