Creé un nuevo repositorio local de Git:

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

¿Hay algún comando git para crear un nuevo repositorio remoto y enviar mi confirmación a GitHub desde aquí? Sé que no es gran cosa simplemente encender un navegador y dirigirse a Crear un nuevo repositorio , pero si hay una manera de lograr esto desde la CLI, sería feliz.

Leí una gran cantidad de artículos, pero ninguno que encontré menciona cómo crear un repositorio remoto desde la CLI usando comandos git. El bonito artículo de Tim Lucas La configuración de un nuevo repositorio git remoto es lo más cercano que encontré, pero GitHub no proporciona acceso de shell .

Puede crear un repositorio de GitHub a través de la línea de comando utilizando la API de GitHub. Echa un vistazo a la API del repositorio . Si se desplaza hacia abajo aproximadamente un tercio del camino, verá una sección titulada "Crear" que explica cómo crear un repositorio a través de la API (justo encima de eso hay una sección que explica cómo bifurcar un repositorio con la API también ) Obviamente, no puede githacerlo, pero puede hacerlo a través de la línea de comandos con una herramienta como curl.

Fuera de la API, no hay forma de crear un repositorio en GitHub a través de la línea de comando. Como notó, GitHub no permite el acceso de shell, etc., por lo que, aparte de la API de GitHub, la única forma de crear un repositorio es a través de la interfaz web de GitHub.

Comandos de la CLI para github API v3 (reemplace todas las palabras clave 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

Esto se puede hacer con tres 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

(actualizado para v3 Github API)

Explicación de estos comandos ...

Crear repositorio github

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

• curl es un comando unix (el anterior también funciona en mac) que recupera e interactúa con las URL. Por lo general, ya está instalado.
• "-u" es un parámetro curl que especifica el nombre de usuario y la contraseña que se utilizarán para la autenticación del servidor.
  • Si solo le da el nombre de usuario (como se muestra en el ejemplo anterior), curl le pedirá una contraseña.
  • Si no desea tener que escribir la contraseña, consulte la documentación de la API de githubs sobre Autenticación
• "-d" es un parámetro curl que le permite enviar datos POST con la solicitud
  • Está enviando datos POST en formato API definido por githubs
• "nombre" es el único dato POST requerido; Me gusta incluir también "descripción"
• Descubrí que era bueno citar todos los datos POST con comillas simples ''

Definir dónde empujar

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

• agregar definición para ubicación y existencia de repositorio conectado (remoto) en github
• "origen" es un nombre predeterminado utilizado por git para el origen de la fuente
  • técnicamente no provenía de github, pero ahora el repositorio de github será la fuente de registro
• "git@github.com: nyeates" es una conexión ssh que asume que ya ha configurado un par de claves ssh de confianza con github.

Empuje el repositorio local a github

git push origin master

• empujar al origen remoto (github) desde la rama local maestra

Si instala la excelente herramienta Hub de defunkt , entonces esto se vuelve tan fácil como

git create

En palabras del autor, " hub es un contenedor de línea de comandos para git que te hace mejor en GitHub " .

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

1. Instalar Hub ( GitHub ).

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

   • de lo contrario (teniendo Go también):

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

2. Vaya a su cesión temporal o crear un vacío: mkdir foo && cd foo && git init.

3. Ejecutar: hub createle preguntará acerca de las credenciales de GitHub por primera vez.

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

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

   Hub solicitará el nombre de usuario y contraseña de GitHub la primera vez que necesite acceder a la API e intercambiarla por un OAuthtoken, que guarda en ~/.config/hub.

   Para nombrar explícitamente el nuevo repositorio, pase NAME, opcionalmente en ORGANIZATION/NAMEforma para crear bajo una organización de la que es miembro.

   Con -p, cree un repositorio privado, y con -dy -hestablezca la descripción y la página de inicio del repositorio URL, respectivamente.

   Para evitar que se le solicite, use GITHUB_USERy GITHUB_PASSWORDvariables de entorno.

4. Luego confirme y presione como de costumbre o marque hub commit/ hub push.

Para obtener más ayuda, ejecute: hub help.

Ver también: Importar un repositorio de Git usando la línea de comando en GitHub.

Hay una gema oficial de github que, creo, hace esto. Intentaré agregar más información a medida que aprenda, pero recién ahora estoy descubriendo esta gema, así que todavía no sé mucho.

ACTUALIZACIÓN: Después de configurar mi clave API, puedo crear un nuevo repositorio en github a través del createcomando, sin embargo, no puedo usar el create-from-localcomando, que se supone que toma el repositorio local actual y realiza un control remoto correspondiente en github.

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

Si alguien tiene alguna idea sobre esto, me encantaría saber qué estoy haciendo mal. Ya hay un problema presentado .

ACTUALIZACIÓN: Eventualmente conseguí que esto funcionara. No estoy exactamente seguro de cómo volver a producir el problema, pero recién comencé desde cero (eliminé la carpeta .git)

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

Ahora esta línea creará el repositorio remoto e incluso lo empujará, pero desafortunadamente no creo que pueda especificar el nombre del repositorio que me gustaría. Quería que se llamara "dotfiles" en github, pero la gema gh solo usaba el nombre de la carpeta actual, que era "jason" desde que estaba en mi carpeta de inicio. (Agregué un ticket pidiendo el comportamiento deseado)

gh create-from-local

Este comando, por otro lado, acepta un argumento para especificar el nombre del repositorio remoto, pero está destinado a comenzar un nuevo proyecto desde cero, es decir, después de llamar a este comando, obtiene un nuevo repositorio remoto que rastrea un repositorio local en una subcarpeta recién creada en relación con su posición actual, ambos con el nombre especificado como argumento.

gh create dotfiles

Para crear rápidamente el repositorio remoto utilizando un Bash Shell

Es engorroso escribir el código completo cada vez que se crea un repositorio

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

Un enfoque más fácil es:

1. crear un script de shell en un directorio, es decir, / home / USER_NAME / Desktop / my_scripts llamado githubscript.sh
2. Modifique y guarde el siguiente código en el githubscript.sharchivo
   

#!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 Aquí $1está lo repository nameque se pasa como argumentinvocando elscript Cambio YOUR_GITHUB_USER_NAMEantes de guardar el script.

3. Establezca los permisos necesarios para script archivo chmod 755 githubscript.sh

4. Incluya el directorio de scripts en el archivo de configuración del entorno. nano ~/.profile; export PATH="$PATH:$HOME/Desktop/my_scripts"

5. También establezca un alias para ejecutar el archivo githubscript.sh. nano ~/.bashrc; alias githubrepo="bash githubscript.sh"

6. Ahora vuelva a cargar el .bashrcy.profile archivos en la terminal. source ~/.bashrc ~/.profile;

7. Ahora para crear un nuevo repositorio, es decir demo: githubrepo demo;

Basado en la otra respuesta de @Mechanical Snail, excepto sin el uso de python, que me pareció excesivamente exagerado. Agregue esto a su ~/.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"

No, tienes que abrir un navegador al menos una vez para crear tu usernameen GitHub, una vez creado, puedes aprovechar la API de GitHub para crear repositorios desde la línea de comandos, siguiendo el siguiente comando:

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

Por ejemplo:

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

Para los usuarios con autenticación de dos factores, puede usar la solución de bennedich, pero solo necesita agregar el encabezado X-Github-OTP para el primer comando. Reemplace CODE con el código que obtiene del proveedor de autenticación de dos factores. Reemplace USUARIO y REPO con el nombre de usuario y el nombre del repositorio, como lo haría en su solución.

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

Escribí un script ingenioso para esto llamado Gitter usando las API REST para GitHub y 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 = crear nuevo repositorio
• -r = proveedor de repositorio (g = GitHub, b = BitBucket)
• -n = nombrar el repositorio
• -l = (opcional) establece el idioma de la aplicación en el repositorio

He creado un alias de Git para hacer esto, basado en la respuesta de Bennedich . Agregue lo siguiente a su ~/.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 usarlo, ejecuta

$ git hub-new-repo

desde cualquier lugar dentro del repositorio local e ingrese su contraseña de Github cuando se le solicite.

Lo que necesitas es hub . Hub es un contenedor de línea de comandos para git. Se ha hecho para integrarse con git nativo usando alias. Intenta proporcionar acciones de github en git, incluida la creación de un nuevo repositorio.

→  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 los rubíes:

gem install githubrepo
githubrepo create *reponame*

ingrese nombre de usuario y pw como se le solicite

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

Fuente: Elikem Adadevoh

Para todos los usuarios de Python 2.7. *. Hay un contenedor de Python alrededor de la API de Github que se encuentra actualmente en la Versión 3, llamado GitPython . Simplemente instale usando easy_install PyGithubo 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)

Los Repositorydocumentos del objeto están aquí .

Para obtener instrucciones sobre cómo crear un token, vaya aquí. Este es el comando que escribirá (a partir de la fecha de esta respuesta. (Reemplace todas las palabras clave CAPS):

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

Una vez que ingrese su contraseña, verá lo siguiente que contiene su 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"
}

Puede revocar su token en cualquier momento yendo aquí

Por razones de representación, no puedo agregar esto como un comentario (donde sería mejor ir con la respuesta de Bennedich ), pero para la línea de comandos de Windows, aquí está la sintaxis correcta:

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

Es la misma forma básica, pero debe usar comillas dobles (") en lugar de simples, y escapar de las comillas dobles enviadas en los parámetros POST (después del indicador -d) con barras invertidas. También eliminé las comillas simples alrededor de mi nombre de usuario, pero si su nombre de usuario tuviera un espacio (¿posible?) probablemente necesitaría comillas dobles.

Descargo de responsabilidad: soy el autor del proyecto de código abierto

Esta funcionalidad es compatible con: https://github.com/chrissound/Human-Friendly-Commands esencialmente es 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
};

Encontré esta solución que me gustó: https://medium.com/@jakehasler/how-to-create-a-remote-git-repo-from-the-command-line-2d6857f49564

Primero debe crear un token de acceso personal de Github

Abra su ~ / .bash_profile o ~ / .bashrc en su editor de texto favorito. Agregue la siguiente línea cerca de la parte superior de su archivo, donde se encuentran el resto de las variables exportadas:

export GITHUB_API_TOKEN=<your-token-here>

En algún lugar a continuación, mediante sus otras funciones bash, puede pegar algo similar a lo siguiente:

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

Ahora, cada vez que cree un nuevo proyecto, puede ejecutar el comando $ new-git awesome-repopara crear un nuevo repositorio remoto público en su cuenta de usuario de Github.

Con la nueva interfaz de línea de comando oficial de Github :

gh repo create

Ver detalles adicionales y opciones e instrucciones de instalación .

Por ejemplo, para completar su flujo de trabajo 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

Aquí están mis comandos iniciales de git (posiblemente, esta acción tiene lugar en 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

Recientemente me enteré de create-github-repo . Del léame:

Instalar en pc:

$ npm i -g create-github-repo

Uso:

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

O:

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

crear un nuevo repositorio en la línea de comando

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

empujar un repositorio existente desde la línea de comando

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

git push -u origin master