Criei um novo repositório Git local:

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

Existe algum comando git para criar um novo repositório remoto e enviar por push meu commit ao GitHub a partir daqui? Eu sei que não é grande coisa apenas iniciar um navegador e ir para Criar um novo repositório , mas se houver uma maneira de conseguir isso com a CLI, eu ficaria feliz.

Li uma grande quantidade de artigos, mas nenhum que encontrei mencionou como criar um repositório remoto a partir da CLI usando comandos git. Artigo agradável de Tim Lucas Configurar um novo repositório remoto do git é o mais próximo que encontrei, mas o GitHub não fornece acesso ao shell .

Você pode criar um repositório GitHub através da linha de comando usando a API do GitHub. Confira a API do repositório . Se você rolar cerca de um terço do caminho, verá uma seção intitulada "Criar" que explica como criar um repositório via API (logo acima, é uma seção que explica como bifurcar um repositório com a API também ) Obviamente, você não pode usar gitisso, mas pode fazê-lo através da linha de comando com uma ferramenta semelhante curl.

Fora da API, não há como criar um repositório no GitHub através da linha de comando. Como você observou, o GitHub não permite acesso ao shell etc., portanto, além da API do GitHub, a única maneira de criar um repositório é através da interface da web do GitHub.

Comandos da CLI para a API do github v3 (substitua todas as palavras-chave do 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

Isso 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 git@github.com:nyeates/projectname.git
git push origin master

(atualizado para a API do Github v3)

Explicação desses comandos ...

Criar repositório github

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

• curl é um comando unix (acima também funciona no mac) que recupera e interage com URLs. Geralmente já está instalado.
• "-u" é um parâmetro de ondulação que especifica o nome do usuário e a senha a serem usados ​​na autenticação do servidor.
  • Se você apenas der o nome de usuário (como mostrado no exemplo acima), o curl solicitará uma senha.
  • Se você não quiser digitar a senha, consulte a documentação da API do githubs em Authentication
• "-d" é um parâmetro de curvatura que permite enviar dados POST com a solicitação
  • Você está enviando dados POST no formato API definido pelo githubs
• "nome" é o único dado POST necessário; Eu também gosto de incluir "descrição"
• Descobri que era bom citar todos os dados do POST com aspas simples ''

Defina para onde empurrar

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

• adicionar definição para localização e existência de repositório conectado (remoto) no github
• "origem" é um nome padrão usado pelo git para a origem da origem
  • tecnicamente não veio do github, mas agora o repositório do github será a fonte do registro
• "git@github.com: nyeates" é uma conexão ssh que pressupõe que você já configurou um par de chaves ssh confiável com o github.

Enviar repositório local para o github

git push origin master

• enviar para o controle remoto de origem (github) da ramificação local principal

Se você instalar a excelente ferramenta Hub do defunkt , isso se tornará tão fácil quanto

git create

Nas palavras do autor, "o hub é um wrapper de linha de comando para o git que o aprimora no GitHub " .

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

1. Instale o Hub ( GitHub ).

   • OS X: brew install hub
   • Tendo Go :go get github.com/github/hub

   • caso contrário (tendo Go também):

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

2. Vá para o seu repo ou criar um vazio: mkdir foo && cd foo && git init.

3. Executar:, hub createele perguntará sobre as credenciais do GitHub pela primeira vez.

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

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

   O Hub solicitará o nome de usuário e a senha do GitHub na primeira vez em que precisar acessar a API e trocará por um OAuthtoken, no qual ele será salvo ~/.config/hub.

   Para nomear explicitamente o novo repositório, passe NAME, opcionalmente, no ORGANIZATION/NAMEformulário para criar em uma organização da qual você é membro.

   Com -p, crie um repositório privado, e com -de -hdefina a descrição e a página inicial do repositório URL, respectivamente.

   Para evitar ser solicitado, use GITHUB_USERe GITHUB_PASSWORDvariáveis ​​de ambiente.

4. Em seguida, confirme e empurre como de costume ou marque hub commit/ hub push.

Para obter mais ajuda, execute: hub help.

Consulte também: Importando um repositório Git usando a linha de comando no GitHub.

Existe uma jóia oficial do github que, eu acho, faz isso. Vou tentar adicionar mais informações à medida que aprender, mas só agora estou descobrindo essa gema, então ainda não sei muito.

ATUALIZAÇÃO: Depois de definir minha chave de API, sou capaz de criar um novo repositório no github por meio do createcomando, no entanto, não consigo usar o create-from-localcomando, que deve pegar o repositório local atual e fazer um controle remoto correspondente no github.

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

Se alguém tiver alguma idéia sobre isso, eu adoraria saber o que estou fazendo de errado. Já existe um problema arquivado .

ATUALIZAÇÃO: Acabei conseguindo que isso funcionasse. Não sei exatamente como reproduzir o problema, mas comecei do zero (excluí a pasta .git)

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

Agora, essa linha criará o repositório remoto e chegará até ele, mas infelizmente não acho que posso especificar o nome do repositório que gostaria. Eu queria que ele fosse chamado de "dotfiles" no github, mas a gh gem apenas usou o nome da pasta atual, que era "jason" desde que eu estava na minha pasta pessoal. (Adicionei um ticket solicitando o comportamento desejado)

gh create-from-local

Este comando, por outro lado, aceita um argumento para especificar o nome do repositório remoto, mas destina-se a iniciar um novo projeto do zero, ou seja, depois que você chama esse comando, você obtém um novo repositório remoto que rastreia um repositório local em uma subpasta criada recentemente em relação à sua posição atual, ambas com o nome especificado como argumento.

gh create dotfiles

Para criar rapidamente o repositório remoto usando um shell Bash

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

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

Uma abordagem mais fácil é:

1. crie um script de shell em um diretório, por exemplo, / home / USER_NAME / Desktop / my_scripts chamado githubscript.sh
2. Modifique e salve o seguinte código no githubscript.sharquivo
   

#!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 Aqui $1está o repository nameque é passado como argumentquando se chama ascript alteração YOUR_GITHUB_USER_NAMEantes de salvar o script.

3. Defina as permissões necessárias para o scriptarquivo chmod 755 githubscript.sh

4. Inclua o diretório de scripts no arquivo de configuração do ambiente. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. Defina também um alias para executar o arquivo githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Agora recarregue os arquivos .bashrce .profileno terminal. source ~/.bashrc ~/.profile;

7. Agora, para criar um novo repositório, ou seja demo: githubrepo demo;

Com base na outra resposta de @Mechanical Snail, exceto sem o uso de python, que eu achei muito exagero. Adicione isso 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 git@github.com:$GHUSER/$REPO.git; git push origin master"

Não, você precisa abrir um navegador pelo menos uma vez para criar o seu usernameno GitHub, uma vez criado, você pode aproveitar a API do GitHub para criar repositórios a partir da linha de comando, seguindo o comando abaixo:

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 usuários com autenticação de dois fatores, você pode usar a solução de bennedich, mas você só precisa adicionar o cabeçalho X-Github-OTP para o primeiro comando. Substitua CODE pelo código que você obtém do provedor de autenticação de dois fatores. Substitua USER e REPO pelo nome de usuário e nome do repositório, como 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 git@github.com:USER/REPO.git
git push origin master

Eu escrevi um script bacana para isso chamado Gitter usando as APIs REST 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 novo repositório
• -r = provedor de repositório (g = GitHub, b = BitBucket)
• -n = nomeie o repo
• -l = (opcional) define o idioma do aplicativo no repositório

Eu criei um alias do Git para fazer isso, com base 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\", \"git@github.com:{0}/{1}.git\".format(user, repo)]); check_call([\"git\", \"push\", \"origin\", \"master\"])'"

Para usá-lo, execute

$ git hub-new-repo

de qualquer lugar dentro do repositório local e digite sua senha do Github quando solicitado.

O que você precisa é de hub . Hub é um wrapper de linha de comando para o git. Foi criado para integrar com o git nativo usando o alias. Ele tenta fornecer ações do github no 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

Para Rubyists:

gem install githubrepo
githubrepo create *reponame*

digite o nome de usuário e senha conforme solicitado

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

Fonte: Elikem Adadevoh

Para todos os usuários do Python 2.7. *. Há um wrapper Python em torno da API do Github que está atualmente na versão 3, chamado GitPython . Basta instalar usando easy_install PyGithubou 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)

A Repositorydocumentação do objeto está aqui .

Para obter instruções sobre como criar um token, clique aqui Este é o comando que você digitará (na data desta resposta. (Substitua todas as palavras-chave do CAPS):

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

Depois de inserir sua senha, você verá o seguinte, que contém 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"
}

Você pode revogar seu token a qualquer momento acessando aqui

Por motivos de representação, não posso adicionar isso como um comentário (onde seria melhor ir com a resposta de bennedich ), mas para a linha de comando do Windows, aqui está a sintaxe correta:

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

É a mesma forma básica, mas você deve usar aspas duplas (") em vez de simples e escapar das aspas duplas enviadas nos parâmetros POST (após o sinalizador -d) com barras invertidas. Também removi as aspas simples ao redor do meu nome de usuário, mas se seu nome de usuário tivesse um espaço (possível?), provavelmente precisaria de aspas duplas.

Disclamier: Sou o autor do projeto de código aberto

Esta funcionalidade é suportada por: https://github.com/chrissound/Human-Friendly-Commands 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 git@github.com:"$GITHUB_USER"/"$projName".git
  git push origin master
};

Encontrei esta solução que eu gostei: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Primeiro, você precisa criar um token de acesso pessoal do Github

Abra seu ~ / .bash_profile ou ~ / .bashrc no seu editor de texto favorito. Adicione a seguinte linha perto da parte superior do seu arquivo, onde as demais variáveis ​​exportadas são:

export GITHUB_API_TOKEN=<your-token-here>

Em algum lugar abaixo, pelas suas outras funções do 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 você estiver criando um novo projeto, você pode executar o comando $ new-git awesome-repopara criar um novo repositório remoto público na sua conta de usuário do Github.

Com a nova interface de linha de comando oficial do Github :

gh repo create

Veja detalhes adicionais e opções e instruções de instalação .

Por exemplo, para concluir seu fluxo de trabalho 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

aqui estão meus comandos git iniciais (possivelmente, esta ação ocorre 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 o create-github-repo . No leia-me:

Instalar:

$ npm i -g create-github-repo

Uso:

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

crie 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

envie um repositório existente a partir da linha de comando

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

git push -u origin master