Utworzyłem nowe lokalne repozytorium Git:

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

Czy jest jakieś polecenie git, aby utworzyć nowe zdalne repozytorium i wcisnąć moje zatwierdzenie do GitHub z tego miejsca? Wiem, że to nie jest wielka sprawa po prostu uruchomić przeglądarkę i przejść do utworzenia nowego repozytorium , ale jeśli istnieje sposób na osiągnięcie tego z poziomu interfejsu CLI, byłbym szczęśliwy.

Przeczytałem ogromną liczbę artykułów, ale żaden z nich nie wspomniał o tym, jak utworzyć zdalne repozytorium z poziomu interfejsu CLI za pomocą poleceń git. Miły artykuł Tima Lucas'a. Konfigurowanie nowego zdalnego repozytorium git jest najbliższe, jakie znalazłem, ale GitHub nie zapewnia dostępu do powłoki .

Możesz utworzyć repozytorium GitHub za pomocą wiersza poleceń za pomocą interfejsu API GitHub. Sprawdź interfejs API repozytorium . Jeśli przewiniesz w około jedną trzecią drogi, zobaczysz sekcję zatytułowaną „Utwórz”, która wyjaśnia, jak utworzyć repozytorium za pośrednictwem interfejsu API (tuż powyżej jest to sekcja wyjaśniająca, jak rozwidlać repo za pomocą interfejsu API ). Oczywiście nie możesz tego użyć git, ale możesz to zrobić za pomocą wiersza poleceń za pomocą narzędzia takiego jakcurl .

Poza interfejsem API nie ma możliwości utworzenia repozytorium w GitHub za pomocą wiersza polecenia. Jak zauważyłeś, GitHub nie pozwala na dostęp do powłoki itp., Więc oprócz GitHub API jedynym sposobem na utworzenie repo jest interfejs sieciowy GitHub.

Polecenia CLI dla github API v3 (zamień wszystkie słowa kluczowe 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

Można to zrobić za pomocą trzech poleceń:

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

(zaktualizowano dla Github API v3)

Objaśnienie tych poleceń ...

Utwórz repozytorium github

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

• curl to komenda unix (powyżej działa również na Macu), która pobiera adresy URL i wchodzi w interakcje z nimi. Zwykle jest już zainstalowany.
• „-u” to parametr curl, który określa nazwę użytkownika i hasło używane do uwierzytelnienia serwera.
  • Jeśli podasz tylko nazwę użytkownika (jak pokazano w powyższym przykładzie), curl poprosi o podanie hasła.
  • Jeśli nie chcesz wpisywać hasła, zapoznaj się z dokumentacją interfejsu API githubs dotyczącą uwierzytelniania
• „-d” to parametr curl, który umożliwia wysyłanie danych POST z żądaniem
  • Wysyłasz dane POST w formacie API zdefiniowanym przez githubs
• „nazwa” to jedyne wymagane dane POST; Chciałbym również dołączyć „opis”
• Stwierdziłem, że dobrze jest cytować wszystkie dane POST pojedynczymi cudzysłowami ''

Określ, gdzie naciskać

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

• dodaj definicję lokalizacji i istnienia podłączonego (zdalnego) repozytorium na github
• „origin” jest domyślną nazwą używaną przez git dla źródła, z którego pochodzi źródło
  • technicznie nie pochodziło z github, ale teraz repozytorium github będzie źródłem nagrań
• „git@github.com: nyeates” to połączenie ssh, które zakłada, że ​​masz już skonfigurowaną zaufaną parę kluczy ssh w github.

Przekaż lokalne repozytorium do github

git push origin master

• wypchnij do źródłowego pilota zdalnego (github) z głównej gałęzi lokalnej

Jeśli zainstalujesz doskonałe narzędzie Hub firmy Defunkt , stanie się to tak proste, jak

git create

Według autora: „ hub to opakowanie wiersza polecenia dla git, dzięki któremu jesteś lepszy w GitHub ”.

Proste kroki (używając git+ hub=> GitHub ):

1. Zainstaluj Hub ( GitHub ).

   • OS X: brew install hub
   • mając Go :go get github.com/github/hub

   • w przeciwnym razie (również Go ):

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

2. Przejdź do repo lub utworzyć pustą: mkdir foo && cd foo && git init.

3. Uruchom: hub createpo raz pierwszy zapyta Cię o poświadczenia GitHub.

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

   Przykład: hub create -d Description -h example.com org_name/foo_repo

   Hub wyświetli monit o podanie nazwy użytkownika i hasła GitHub, gdy po raz pierwszy będzie potrzebował uzyskać dostęp do interfejsu API i wymienić go na OAuthtoken, który zapisuje~/.config/hub .

   Aby jawnie nazwać nowe repozytorium, przekaż NAME, opcjonalnie w ORGANIZATION/NAMEformie, aby utworzyć w organizacji, do której należysz.

   Za pomocą -putwórz prywatne repozytorium, a następnie za pomocą -di -hustaw odpowiednio opis repozytorium i stronę główną URL.

   Aby uniknąć monitowania, użyj zmiennych środowiskowych GITHUB_USERi GITHUB_PASSWORD.

4. Następnie zatwierdzaj i pchaj jak zwykle lub zaznacz hub commit/ hub push.

Aby uzyskać więcej pomocy, uruchom: hub help.

Zobacz także: Importowanie repozytorium Git przy użyciu wiersza polecenia w GitHub.

Istnieje oficjalny klejnot github który, jak sądzę, robi to. W miarę uczenia się postaram się dodać więcej informacji, ale dopiero teraz odkrywam ten klejnot, więc jeszcze niewiele wiem.

AKTUALIZACJA: Po ustawieniu mojego klucza API jestem w stanie utworzyć nowe repo na githubie za pomocą createpolecenia, jednak nie jestem w stanie użyć create-from-localpolecenia, które ma przejąć bieżące lokalne repo i wykonać odpowiedni zdalny na github.

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

Jeśli ktoś ma wgląd w to, chciałbym wiedzieć, co robię źle. Problem został już zgłoszony .

AKTUALIZACJA: W końcu udało mi się to uruchomić. Nie jestem do końca pewien, jak odtworzyć problem, ale właśnie zacząłem od zera (usunąłem folder .git)

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

Teraz ten wiersz utworzy zdalne repozytorium, a nawet go wypchnie, ale niestety nie sądzę, żebym mógł podać nazwę repozytorium, które chciałbym. Chciałem, aby nazywało się to „dotfiles” na githubie, ale klejnot gh właśnie użył nazwy bieżącego folderu, którym był „jason”, ponieważ byłem w folderze domowym. (Dodałem bilet z prośbą o pożądane zachowanie)

gh create-from-local

Z drugiej strony to polecenie przyjmuje argument określający nazwę zdalnego repozytorium, ale jest ono przeznaczone do rozpoczęcia nowego projektu od zera, tj. Po wywołaniu tej komendy otrzymujesz nowe zdalne repozytorium, które śledzi repozytorium lokalne w nowo utworzonym podfolderze w stosunku do bieżącej pozycji, oba o nazwie określonej jako argument.

gh create dotfiles

Aby szybko utworzyć zdalne repozytorium za pomocą powłoki Bash

Uciążliwe jest wpisywanie pełnego kodu za każdym razem, gdy ma zostać utworzone repozytorium

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

Łatwiejszym podejściem jest:

1. utwórz skrypt powłoki w katalogu tj. / home / USER_NAME / Desktop / my_scripts o nazwie githubscript.sh
2. Zmodyfikuj i zapisz następujący kod w githubscript.shpliku
   

#!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 Tutaj $1jest repository name, który jest przekazywany jako argumentpodczas wywoływaniascript Change YOUR_GITHUB_USER_NAMEprzed zapisaniem skryptu.

3. Ustaw wymagane uprawnienia do scriptpliku chmod 755 githubscript.sh

4. Dołącz katalog skryptów do pliku konfiguracyjnego środowiska. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. Ustaw także alias, aby uruchomić plik githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Teraz ponownie załaduj pliki .bashrci .profilew terminalu. source ~/.bashrc ~/.profile;

7. Teraz, aby utworzyć nowe repozytorium, tj . demo: githubrepo demo;

Na podstawie innej odpowiedzi @Mechanical Snail, z wyjątkiem bez użycia pytona, który okazał się szalenie przesadny. Dodaj to do ~/.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"

Nie, musisz przynajmniej raz otworzyć przeglądarkę, aby utworzyć usernameGitHub. Po utworzeniu możesz wykorzystać interfejs API GitHub do tworzenia repozytoriów z wiersza poleceń, postępując zgodnie z poniższym poleceniem:

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

Na przykład:

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

W przypadku użytkowników z uwierzytelnianiem dwuskładnikowym możesz skorzystać z rozwiązania Bennedicha, ale wystarczy dodać nagłówek X-Github-OTP dla pierwszego polecenia. Zamień KOD na kod otrzymany od dostawcy uwierzytelniania dwuskładnikowego. Zastąp USER i REPO nazwą użytkownika i nazwą repozytorium, tak jak w jego rozwiązaniu.

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

Napisałem fajny skrypt dla tego o nazwie Gitter przy użyciu interfejsów API REST dla GitHub i 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 = utwórz nowe repozytorium
• -r = dostawca repo (g = GitHub, b = BitBucket)
• -n = nazwij repozytorium
• -l = (opcjonalnie) ustaw język aplikacji w repozytorium

Stworzyłem alias Git, aby to zrobić, w oparciu o odpowiedź Bennedicha . Dodaj następujące elementy do ~/.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\"])'"

Aby go użyć, uruchom

$ git hub-new-repo

z dowolnego miejsca w lokalnym repozytorium i po wyświetleniu monitu wprowadź hasło do Github.

Potrzebny jest hub . Hub to opakowanie linii poleceń dla git. Został stworzony do integracji z natywnym gitem przy użyciu aliasu. Próbuje udostępniać akcje github w git, w tym tworzenie nowego repozytorium.

→  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

Dla rubistów:

gem install githubrepo
githubrepo create *reponame*

wprowadź nazwę użytkownika i pw zgodnie z monitem

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

Źródło: Elikem Adadevoh

Dla wszystkich użytkowników Python 2.7. *. Wokół interfejsu API Github, który jest obecnie w wersji 3, znajduje się opakowanie Pythona o nazwie GitPython . Po prostu zainstaluj za pomocą easy_install PyGithublub 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)

Dokumenty Repositoryobiektowe są tutaj .

Aby uzyskać wskazówki na temat tworzenia tokena, przejdź tutaj To polecenie, które wpiszesz (od daty tej odpowiedzi. (Zamień wszystkie słowa kluczowe CAPS):

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

Po wprowadzeniu hasła zobaczysz następujące informacje, które zawierają 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"
}

Możesz odwołać swój token w dowolnym momencie, przechodząc tutaj

Z powodów związanych z powtórzeniami nie mogę dodać tego jako komentarza (w przypadku, gdy lepiej pójść z odpowiedzią Bennedicha) ), ale dla wiersza poleceń systemu Windows oto poprawna składnia:

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

Jest to ta sama podstawowa forma, ale musisz użyć podwójnych cudzysłowów („) zamiast pojedynczych i unikaj podwójnych cudzysłowów wysyłanych w parametrach POST (po flagach -d) z odwrotnymi ukośnikami. Usunąłem też pojedyncze cudzysłowy wokół mojej nazwy użytkownika, ale jeśli twoja nazwa użytkownika ma spację (możliwe?), prawdopodobnie potrzebowałaby podwójnych cudzysłowów.

Disclamier: Jestem autorem projektu open source

Ta funkcja jest obsługiwana przez: https://github.com/chrissound/Human-Friendly-Commands zasadniczo jest to następujący skrypt:

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

Znaleziono to rozwiązanie, które mi się podobało: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Najpierw musisz utworzyć osobisty token dostępu Github

Otwórz ~ / .bash_profile lub ~ / .bashrc w swoim ulubionym edytorze tekstu. Dodaj następujący wiersz u góry pliku, w którym znajdują się pozostałe zmienne eksportowane:

export GITHUB_API_TOKEN=<your-token-here>

Gdzieś poniżej, za pomocą innych funkcji bash, możesz wkleić coś podobnego do następującego:

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

Teraz za każdym razem, gdy tworzysz nowy projekt, możesz uruchomić polecenie $ new-git awesome-repoutworzenia nowego publicznego zdalnego repozytorium na koncie użytkownika Github.

Dzięki oficjalnemu nowemu interfejsowi wiersza poleceń Github :

gh repo create

Zobacz dodatkowe szczegóły i opcje oraz instrukcje instalacji .

Na przykład, aby zakończyć proces pracy z 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

oto moje początkowe polecenia git (być może ta akcja ma miejsce 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

Niedawno dowiedziałem się o create-github-repo . Z pliku Readme:

Zainstalować:

$ npm i -g create-github-repo

Stosowanie:

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

Lub:

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

utwórz nowe repozytorium w wierszu poleceń

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

wypchnij istniejące repozytorium z wiersza poleceń

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

git push -u origin master