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 [email protected]: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 [email protected]:nyeates/projectname.git
git push origin master

Wyjaśnienie tych poleceń...

Utwórz github repo

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

• curl to polecenie uniksowe (powyższe działa również na Macu), które pobiera i współdziała z adresami URL. Jest powszechnie już zainstalowany.
• " - u " jest parametrem curl, który określa nazwę użytkownika i hasło używane do uwierzytelniania serwera.
  • Jeśli podasz tylko nazwę użytkownika (jako pokazane 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 na temat uwierzytelniania

Określ, do którego miejsca nacisnąć

git remote add origin [email protected]:nyeates/projectname.git

[16]} dodaj definicję lokalizacji i istnienia podłączonego (zdalnego) repo na github
• "origin" jest domyślną nazwą używaną przez git dla tego, skąd pochodzi źródło
  Teoretycznie nie pochodzi z Githuba, ale teraz repo Githuba będzie źródłem zapisu]}
• "[email protected]:nyeates" jest połączeniem ssh, które zakłada, że już skonfigurowałeś zaufane SSH keypair z github.

Push local repo to github

git push origin master

[16]}push To The origin remote (github) from the master local branch

Jeśli zainstalujesz defunkt ' S excellent Hub Narzędzie, wtedy stanie się to tak proste jak

git create

W słowach autora, " hub jest opakowaniem wiersza poleceń dla Gita, który sprawia, że jesteś lepszy w Githubie."

Proste kroki (za pomocą git + hub => GitHub):

1. Install Hub (GitHub ).

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

   • Inaczej (mając iść również):

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

2. Przejdź do repo lub utwórz pustą: mkdir foo && cd foo && git init.

3. Run: hub create, zapyta Cię o poświadczenia GitHub po raz pierwszy.

   Użycie: hub create [-p] [-d DESCRIPTION] [-h HOMEPAGE] [NAME]

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

   Hub zapyta o nazwę Użytkownika i hasło GitHub, gdy po raz pierwszy będzie musiał uzyskać dostęp do API i wymienić je na token OAuth, który zapisuje w ~/.config/hub.

   Aby jawnie nazwać nowe repozytorium, podaj NAME, opcjonalnie w formularzu ORGANIZATION/NAME do utworzenia w ramach organizacji jesteś członkiem.

   Z -p, Utwórz prywatne repozytorium, a z -d i -h ustawiają opis repozytorium i stronę główną URL, odpowiednio.

   Aby uniknąć monitu, użyj zmiennych środowiskowych GITHUB_USER i GITHUB_PASSWORD.

4. Następnie zatwierdź i wciśnij jak zwykle lub sprawdź hub commit/hub push.

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

Zobacz także: Importowanie repozytorium Gita za pomocą wiersza poleceń na GitHub.

Istnieje oficjalny Gem github , który, myślę, robi to. Postaram się dodać więcej informacji, jak się dowiem, ale dopiero teraz odkrywam ten klejnot, więc nie wiem jeszcze wiele.

UPDATE: po ustawieniu klucza API, jestem w stanie utworzyć nowe repo na GitHubie za pomocą polecenia create, jednak nie jestem w stanie użyć polecenia create-from-local, które ma pobierać bieżący lokalny repo i tworzyć odpowiedni zdalny na GitHubie.

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

Jeśli ktoś ma jakiś wgląd w to, Chciałbym wiedzieć, co robię źle. Jest już problem złożony .

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 (usunięty.folder git)

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

Teraz ta linia utworzy zdalny repo i nawet do niego wciśnie, ale niestety nie sądzę, żebym mógł podać nazwę repo, którą chciałbym. Chciałem, żeby to się nazywało "dotfiles" na GitHubie, ale GH gem właśnie użył nazwy bieżący folder, który był "jason", ponieważ byłem w moim folderze domowym. (Dodałem bilet z prośbą o pożądane zachowanie)

gh create-from-local

To polecenie, z drugiej strony, akceptuje argument określający nazwę zdalnego repo, ale jest przeznaczone do rozpoczęcia nowego projektu od zera, tzn. po wywołaniu tego polecenia, otrzymasz nowy zdalny repo, który śledzi lokalny repo w nowo utworzonym podfolderze w stosunku do bieżącej pozycji, oba o nazwie określonej jako kłótnia.

gh create dotfiles

Aby szybko utworzyć zdalne repozytorium przy użyciu powłoki Bash Jest to bardzo proste, ponieważ nie jest to konieczne, aby utworzyć repozytorium.]}

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

Łatwiejsze podejście to:

1. Utwórz skrypt powłoki w katalogu tj./home/USER_NAME/Desktop / my_scripts o nazwie githubscript.sh
2. zmodyfikuj i zapisz poniższy kod do pliku githubscript.sh
   

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

N. B. tutaj $1 jest repository name, który jest przekazywany jako argument podczas wywoływania script Zmień YOUR_GITHUB_USER_NAME przed zapisaniem skryptu.

1. Ustaw wymagane uprawnienia do pliku script chmod 755 githubscript.sh

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

3. Ustaw także alias do uruchomienia githubscript.sh plik. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

4. Teraz przeładuj pliki .bashrc i {[14] } w terminalu. source ~/.bashrc ~/.profile;

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

Dla użytkowników z uwierzytelnianiem dwuskładnikowym, możesz użyć rozwiązania bennedich, ale wystarczy dodać nagłówek X-Github-OTP dla pierwszej komendy. Zastąp kod kodem otrzymanym od dostawcy uwierzytelniania dwuskładnikowego. Zastąp usera 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 [email protected]:USER/REPO.git
git push origin master

Napisałem sprytny skrypt o nazwie Gitter używając reszty API 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 repo
• -r = repo provider (g = GitHub, B = BitBucket)
• -n = Nazwa repo
• -l = (opcjonalnie) Ustaw język aplikacji w repo

Stworzyłem w tym celu alias Git, oparty na odpowiedzi Bennedicha . Dodaj do swojego ~/.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\", \"[email protected]:{0}/{1}.git\".format(user, repo)]); check_call([\"git\", \"push\", \"origin\", \"master\"])'"

Aby go użyć, Uruchom

$ git hub-new-repo

Z dowolnego miejsca wewnątrz lokalnego repozytorium i wprowadź hasło Github po wyświetleniu monitu.

Dla Rubyistów:

gem install githubrepo
githubrepo create *reponame*

Wprowadź nazwę użytkownika i pw jako monit

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

Źródło: Elikem Adadevoh

Na podstawie drugiej odpowiedzi @ Mechanical Snail, z wyjątkiem bez użycia Pythona, który uważam za szalenie przesadzony. Dodaj to do swojego ~/.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 [email protected]:$GHUSER/$REPO.git; git push origin master"

Nie, {[5] } musisz przynajmniej raz otworzyć przeglądarkę, aby utworzyć username na Githubie, po utworzeniu możesz użyć GitHub API , aby utworzyć repozytoria z wiersza poleceń, wykonując poniższe polecenie:

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

Aby uzyskać wskazówki dotyczące tworzenia tokena, przejdź TUTAJ {[4] } jest to polecenie, które wpisujesz (od daty tej odpowiedzi. (Zastąp 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, które zawierają Twój 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"
}

Potrzebujesz piasty . Hub jest opakowaniem wiersza poleceń dla git. Został stworzony do integracji z natywnym git za pomocą aliasu. Próbuje dostarczyć akcje github do Gita, włączając w to utworzenie 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

Z powodów rep, nie mogę dodać tego jako komentarza( gdzie lepiej iść z bennedich odpowiedź ), ale dla linii poleceń systemu Windows, tutaj jest poprawna składnia:

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

To ta sama podstawowa forma, ale musisz użyć podwójnych cudzysłowów ( " ) zamiast pojedynczych i uciec od podwójnych cudzysłowów wysłanych w parametrach postu (po fladze-d) z odwrotnymi ukośnikami. Usunąłem też pojedyncze cudzysłowy wokół mojej nazwy użytkownika, ale jeśli Twoja nazwa użytkownika miała spację (możliwe?) wymagałoby to prawdopodobnie podwójnych cytatów.

Dla wszystkich Pythonów 2.7.* użytkowników. Istnieje otoczka Pythona wokół Github API, który jest obecnie w wersji 3, o nazwie GitPython. Po prostu zainstaluj za pomocą easy_install PyGithub lub 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)

Repository dokumenty obiektu są tutaj .

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

Najpierw musisz utworzyć Github osobisty Token dostępu

Otwórz swoje~/.bash_profile lub ~/.bashrc w ulubionym edytorze tekstu. Dodaj następujący wiersz u góry Pliku, gdzie znajdują się pozostałe zmienne export ' ed:

export GITHUB_API_TOKEN=<your-token-here>

Gdzieś poniżej, przez inne funkcje Basha, 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, gdy tworzysz nowy projekt, możesz uruchomić polecenie $ new-git awesome-repo, aby utworzyć nowe publiczne zdalne repozytorium na swoim koncie użytkownika Github.

Jestem autorem projektu open source

Ta funkcjonalność jest obsługiwana przez: https://github.com/chrissound/LinuxVerboseCommandLib zasadniczo jest to ten 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 [email protected]:"$GITHUB_USER"/"$projName".git
  git push origin master
};

Oto moje początkowe polecenia git (możliwe, że akcja odbywa się w 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

Ostatnio dowiedziałem się ocreate-github-repo . Z readme:

Zainstaluj:

$ npm i -g create-github-repo

Użycie:

$ 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!"

Tworzenie nowego 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

Wypchnięcie istniejącego repozytorium z linii poleceń

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

git push -u origin master