Comandos de CLI do github API v3 (substituir todas as palavras-chave de maiúsculas):

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

Isto pode ser feito com três comandos:

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

(actualizado para a API v3 Github)

Explicação destes comandos...

Cria o GitHub repo

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

• curl é um comando unix (acima funciona no mac também) que recupera e interage com URLs. É comumente já instalado.
• " - u " é um parâmetro curl que especifica o nome de usuário e senha a usar para autenticação de servidor.
  • se apenas der o nome de utilizador (como mostrado no exemplo acima) o curl irá pedir uma senha.
  • Se não quiser ter de escrever a senha, veja a documentação da api do githubs na autenticação
• "- d " é um parâmetro de curva que lhe permite enviar dados de publicação com o pedido
  • está a enviar dados de POST em githubs formato API definido
• "nome" é a única publicação necessária; eu também gosto de incluir "descrição"
Encontrei isto. foi bom citar todos os dados publicados com aspas simples ''

Define onde empurrar para

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

• adicionar uma definição de localização e resistência de um acordo (remoto) ligado ao github
• "origem" é um nome padrão usado pelo git para de onde veio a fonte.
  Tecnicamente não veio de github,mas agora o github repo será a fonte do registro.
• "[email protected]:nyeates" é uma conexão ssh que assume que você já tem configurar um teclado SSH de confiança com o github.

Empurrar o repo local para o github

git push origin master

• empurrar para a origem remota (github) do ramo principal local

Se instalares a ferramentade defunkt Excelente Hub, Então Isto torna-se tão fácil como

git create

Passos simples (usando git + hub => GitHub):

1. Instalar Hub (GitHub ).

   • OS X: brew install hub
   • ter ir: go get github.com/github/hub

   • Caso contrário (tendo também :

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

2. Vá ao seu repo ou crie um vazio: mkdir foo && cd foo && git init.

3. Vai perguntar-te pela primeira vez sobre as credenciais do GitHub.

   Utilização: hub create [-p] [-d DESCRIPTION] [-h HOMEPAGE] [NAME]

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

   O Hub irá pedir o nome de utilizador e senha do GitHub da primeira vez que precisar de aceder à API e trocá-la por um token OAuth, que grava em ~/.config/hub.

   Para nomear explicitamente o novo repositório, passe em NAME, opcionalmente na forma ORGANIZATION/NAME para criar sob uma organização és membro.

   Com -p, criar um repositório privado, e com -d e -h definir a descrição e página inicial do repositório URL, respectivamente.

   Para evitar ser questionado, use as variáveis de ambiente GITHUB_USER e GITHUB_PASSWORD.

4. Em seguida, persistir e empurrar como de costume ou verificar hub commit/hub push.

Para mais ajuda, corra: hub help.

Ver também: importar um repositório Git usando a linha de comandos no GitHub.

UPDATE: depois de definir a minha chave API, sou capaz de criar um novo repo no github através do comando create, no entanto não sou capaz de usar o comando create-from-local, que é suposto pegar no repo local actual e fazer um remoto correspondente no github.

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

Se alguém tem alguma visão sobre adorava saber o que estou a fazer de errado. Já há uma questão arquivada.

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

gh create-from-local

Este comando, por outro lado, aceita um argumento para indicar o nome do repo remoto, mas destina-se a iniciar um novo projecto a partir do zero, ou seja, depois de chamar este comando, obtém um novo repo remoto que está a seguir um repo local numa subpasta recém-criada em relação à sua posição actual, tanto com o nome indicado como o argumento.

gh create dotfiles

Para criar rapidamente o repositório remoto usando uma Shell Bash

É complicado digitar o código completo sempre que um repositório deve ser criado

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

Uma abordagem mais fácil é:

1. crie um programa de consola numa pasta ou seja, / home / USER_ nome/Ecrã/my_ scripts chamado githubscript.sh
2. modificar e gravar o seguinte código no ficheiro 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. aqui $1 está o {[5] } que é passado como um argument ao invocar o script Alterar YOUR_GITHUB_USER_NAME antes de gravar o programa.

1. Mudar as permissões necessárias para o ficheiro script chmod 755 githubscript.sh

2. Incluir a pasta dos programas no ficheiro de configuração do ambiente. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

3. Definir também um nome alternativo para executar o githubscript.sh file. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

4. Agora recarregue os arquivos .bashrc e .profile no terminal. source ~/.bashrc ~/.profile;

5. Agora para criar um novo repositório. demo: githubrepo demo;

Para os utilizadores com autenticação de dois factores, pode usar a solução do bennedich, mas só precisa de adicionar o cabeçalho X-Github-OTP para o primeiro comando. Substituir o código pelo código que você obtém do provedor de autenticação de dois fatores. Substitua o Usuário e o REPO pelo nome de usuário e nome do repositório, como você faria em sua solução.

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

Eu escrevi um script nifty para este chamado Gitter usando o resto APIs para 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 = criar um novo Acordo de recompra
• -r = Fornecedor de acordos de recompra (g = GitHub, b = BitBucket)
• -n = Nome do Acordo de recompra
• -l = (opcional) defina a língua da aplicação no Acordo de recompra

Criei um pseudónimo Git para fazer isto, baseado na resposta de Bennedich . Adicione o seguinte ao seu ~/.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\"])'"

Para o usar, Execute

$ git hub-new-repo

De qualquer lugar dentro do repositório local, e digite a sua senha do Github quando for pedida.

Para Rubistas:

gem install githubrepo
githubrepo create *reponame*

Indique o nome de utilizador e pw conforme solicitado

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

Fonte: Elikem Adadevoh

Baseado na outra resposta de @caracol mecânico, excepto sem o uso de python, que eu achei ser extremamente exagerado. Adicione isto ao seu ~/.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"

Nope, Você tem que abrir um navegador pelo menos uma vez para criar o seu username no GitHub, uma vez criado, você pode alavancar a API do GitHub para criar repositórios a partir da linha de comandos, seguindo abaixo do comando:

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

Por exemplo:

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

Para instruções sobre a criação de um token, vá aqui Este é o comando que você vai digitar (a partir da data desta resposta. (substituir todas as maiúsculas por palavras-chave):

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

Assim que introduzir a sua senha, verá o seguinte que contém o seu 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"
}

O que você precisa é hub. O Hub é um invólucro de linha de comando para o git. Ele foi feito para se integrar com Git nativo usando alias. Ele tenta fornecer ações do github para o git, incluindo a criação de um novo repositório.

→  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

Por razões de rep, não posso adicionar isto como um comentário (onde é melhor ir com a resposta de bennedich ), mas para a linha de comandos do Windows, aqui está a sintaxe correcta:

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

É a mesma forma básica, mas você tem que usar aspas duplas (") em vez de simples, e escapar das aspas duplas enviadas nos parâmetros de POST (após a bandeira-d) com barra invertida. Eu também removi o single cita em torno do meu nome de usuário, mas se o seu nome de usuário tinha um espaço (possível? provavelmente precisaria de aspas duplas.

Para todos os Python 2.7.* usuario. Existe um invólucro em Python em torno da API Github que está actualmente na versão 3, chamado GitPython . Basta instalar usando 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)

Os documentos do objecto Repository estão Aqui.

Primeiro tens de criar um Token de Acesso Pessoal do Github

Abre a tua ~/.bash_profile ou~/.bashrc no seu editor de texto favorito. Adicione a seguinte linha perto do topo do seu ficheiro, onde o resto das variáveis ed de exportação são:

export GITHUB_API_TOKEN=<your-token-here>

Em algum lugar abaixo, pelas outras funções bash, você pode colar algo semelhante ao seguinte:

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

Agora, sempre que estiver a criar um novo projecto, poderá executar o comando $ new-git awesome-repo para criar um novo repositório remoto público na sua conta de utilizador do Github.

Disclamier: eu sou o autor do projeto de código aberto

Esta funcionalidade é suportada por: https://github.com/chrissound/LinuxVerboseCommandLib, essencialmente, é este 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 [email protected]:"$GITHUB_USER"/"$projName".git
  git push origin master
};

Aqui estão os meus comandos iniciais do git (possivelmente, esta acção tem lugar em 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

Recentemente descobri sobre create-github-repo. Do readme:

Install:

$ npm i -g create-github-repo

Utilização:

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

Criar um novo repositório na linha de comandos

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

Enviar um repositório existente a partir da linha de comandos

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

git push -u origin master