supcoflow 0.8.0 → 0.9.0

package/dist/repo-local.js

@@ -30,6 +30,52 @@ export function repoDelOrigin(url) {
     }
     return null;
 }
+// El `origin` con forma de alias de SSH (`git@github-gf0:dueño/repo`, `ssh://git@github-gf0/dueño/repo`): el host no
+// es github.com, pero el dueño/repo sí tiene la forma de uno de GitHub. NO se resuelve (no se corre `ssh` ni se lee su
+// configuración: `Match exec` ejecutaría programas de la persona): sólo se le dice qué asociar a mano, una vez.
+const FORMAS_DE_ALIAS = [
+    /^[A-Za-z0-9._-]+@([A-Za-z0-9._-]+):([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+    /^ssh:\/\/[A-Za-z0-9._-]+@([A-Za-z0-9._-]+)(?::\d+)?\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+];
+export function aliasDelOrigin(url) {
+    const limpia = url.trim();
+    for (const forma of FORMAS_DE_ALIAS) {
+        const m = forma.exec(limpia);
+        if (!m)
+            continue;
+        const repo = `${m[2]}/${m[3]}`;
+        if (m[1].toLowerCase() === "github.com" || !esRepoValido(repo))
+            return null;
+        return { host: m[1], repo };
+    }
+    return null;
+}
+// Lo que se muestra de un `origin`: nunca el usuario:clave@ de una URL (podría ser un token). Las credenciales se quitan de la
+// URL ENTERA y recién después se limita el tamaño (recortar antes dejaría pasar un `@` lejano con su clave a medias). Lo que no se
+// puede interpretar con seguridad no se muestra crudo: sale un marcador neutro.
+const TOPE_DEL_ORIGEN_MOSTRADO = 200;
+export function origenParaMostrar(url) {
+    const limpia = url.trim();
+    const url_ = /^([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^/\s]*)(.*)$/s.exec(limpia);
+    let mostrable = null;
+    if (url_) {
+        // La autoridad llega hasta la primera `/`; el usuario:clave es todo lo anterior al ÚLTIMO `@` de la autoridad.
+        const arroba = url_[2].lastIndexOf("@");
+        const usuario = arroba === -1 ? "" : url_[2].slice(0, arroba).split(":")[0];
+        const host = arroba === -1 ? url_[2] : url_[2].slice(arroba + 1);
+        mostrable = `${url_[1]}${usuario === "git" ? "git@" : ""}${host}${url_[3]}`;
+    }
+    else if (/^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:/.test(limpia)) {
+        mostrable = limpia; // `git@host:o/r`: el usuario de un scp no lleva clave
+    }
+    if (mostrable === null || /\s/.test(mostrable))
+        return "(an address I don't recognize)";
+    return mostrable.length > TOPE_DEL_ORIGEN_MOSTRADO ? mostrable.slice(0, TOPE_DEL_ORIGEN_MOSTRADO) + "…" : mostrable;
+}
+// El remoto de asociación explícita: la persona le dice una sola vez a qué repo de GitHub corresponde este clon cuando su
+// `origin` no es una dirección de GitHub (alias de SSH, otro servidor). Con las mismas formas estrictas de `origin`;
+// nunca se usa para traer nada.
+export const REMOTO_DE_ASOCIACION = "supcoflow";
 export async function leerRepoLocal(git, cwd) {
     const top = await git(["rev-parse", "--show-toplevel"], cwd);
     const raiz = top.codigo === 0 ? top.stdout.trim() : "";
@@ -37,32 +83,68 @@ export async function leerRepoLocal(git, cwd) {
         return { repo: null, raiz: null, motivo: "sin_git" };
     const origin = await git(["remote", "get-url", "origin"], cwd);
     const url = origin.codigo === 0 ? origin.stdout.trim() : "";
+    const repoDelOrigen = url ? repoDelOrigin(url) : null;
+    // Si `origin` es de GitHub, gana `origin`, como siempre.
+    if (repoDelOrigen)
+        return { repo: repoDelOrigen, raiz };
+    const asociado = await git(["remote", "get-url", REMOTO_DE_ASOCIACION], cwd);
+    const urlAsociada = asociado.codigo === 0 ? asociado.stdout.trim() : "";
+    const repoAsociado = urlAsociada ? repoDelOrigin(urlAsociada) : null;
+    if (repoAsociado)
+        return { repo: repoAsociado, raiz };
+    const alias = url ? aliasDelOrigin(url) : null;
+    const comun = { repo: null, raiz, ...(url ? { origen: origenParaMostrar(url) } : {}), ...(urlAsociada ? { hayRemotoSupcoflow: true } : {}) };
     if (!url)
-        return { repo: null, raiz, motivo: "sin_origin" };
-    const repo = repoDelOrigin(url);
-    if (!repo)
-        return { repo: null, raiz, motivo: "origin_no_es_github" };
-    return { repo, raiz };
+        return { ...comun, motivo: "sin_origin" };
+    if (alias)
+        return { ...comun, motivo: "origin_alias_ssh", alias };
+    return { ...comun, motivo: "origin_no_es_github" };
+}
+// El comando exacto que asocia este clon con un repo de GitHub. `add` si todavía no hay remoto `supcoflow`; `set-url` si
+// hay uno que no es una dirección de GitHub.
+export function comandoDeAsociacion(repo, hayRemoto) {
+    return `git remote ${hayRemoto ? "set-url" : "add"} ${REMOTO_DE_ASOCIACION} https://github.com/${repo}.git`;
 }
 const MOTIVOS = {
     sin_git: "this folder isn't a git repo",
     sin_origin: "the repo has no remote called \"origin\"",
     origin_no_es_github: "the \"origin\" remote isn't a GitHub repo",
+    origin_alias_ssh: "the \"origin\" remote isn't a GitHub repo",
 };
+// La frase que dice la verdad sobre un clon que no se puede atar a `repo` (owner/repo de GitHub) y cómo atarlo.
+export function frasePorQueNoAtaClon(local, repo) {
+    if (local.motivo === "sin_git")
+        return "This folder isn't a git clone.";
+    const sugerido = repo ?? local.alias?.repo ?? null;
+    const como = sugerido === null ? ""
+        : ` If this is ${sugerido} on GitHub, tell me once: \`${comandoDeAsociacion(sugerido, local.hayRemotoSupcoflow === true)}\` (it's never fetched).`;
+    if (local.motivo === "origin_alias_ssh" && repo === null && local.alias) {
+        return `Your origin uses the SSH alias \`${local.alias.host}\`, which I don't resolve.${como}`;
+    }
+    const clon = local.origen ? `This clone is \`${local.origen}\`, which I can't tie to github.com${repo ? `/${repo}` : ""}.` : "This clone has no \"origin\" remote I can tie to GitHub.";
+    return `${clon}${como}`;
+}
 export async function repoPedido(d) {
     const local = await leerRepoLocal(d.git, d.cwd);
     if (d.flagRepo !== null) {
         if (!esRepoValido(d.flagRepo)) {
             throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "The value of --repo must be owner/repo (for example owner/my-app), without the URL.");
         }
-        // La raíz sólo se da si el origin local es ESE repo: con otro, lo que se escriba en esta
+        // La raíz sólo se da si el repo local reconocido es ESE repo: con otro, lo que se escriba en esta
         // carpeta (el archivo del proyecto) no le pertenece.
         const mismo = local.repo !== null && local.repo.toLowerCase() === d.flagRepo.toLowerCase();
-        return { repo: d.flagRepo, raiz: mismo ? local.raiz : null };
+        if (mismo)
+            return { repo: d.flagRepo, raiz: local.raiz };
+        // El mensaje de «no es tu clon» dice por qué, y deja el comando exacto para atarlo si la persona SABE que lo es.
+        const sinClon = local.repo !== null
+            ? `This clone is github.com/${local.repo}, not ${d.flagRepo}.`
+            : frasePorQueNoAtaClon(local, d.flagRepo);
+        return { repo: d.flagRepo, raiz: null, sinClon };
     }
     if (local.repo === null) {
         const porque = local.motivo ? MOTIVOS[local.motivo] : "the folder couldn't be read";
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}). Pass --repo owner/repo.`);
+        const detalle = local.motivo === "origin_alias_ssh" ? ` ${frasePorQueNoAtaClon(local, null)}` : "";
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}).${detalle} Pass --repo owner/repo.`);
     }
     return { repo: local.repo, raiz: local.raiz };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supcoflow",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "La terminal de Supcoflow: iniciar sesión y manejar el chat de soporte desde la consola o un asistente.",
   "type": "module",
   "bin": { "supcoflow": "dist/cli.js" },