git0 0.2.99 → 0.3.0

package/dist/cli.js

@@ -23601,6 +23601,9 @@ var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
+// src/cli.ts
+import path6 from "path";
+
 // node_modules/grab-api.js/dist/grab-api.es.js
 function log(message = "", options = {}) {
   let {
@@ -27326,11 +27329,60 @@ function getAvailableDirectoryName(basePath) {
     counter++;
   }
 }
-async function streamTarball(res, extractPath) {
+function normalizeSubPath(raw) {
+  if (!raw)
+    return "";
+  const segments = raw.replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+  if (segments.includes("..")) {
+    throw new Error(`Invalid path "${raw}" — ".." segments are not allowed.`);
+  }
+  return segments.join("/");
+}
+function subPathFilter(subPath) {
+  if (!subPath)
+    return () => true;
+  const prefix = `${subPath}/`;
+  return (entryPath) => {
+    const relative = entryPath.replace(/\\/g, "/").split("/").slice(1).join("/").replace(/\/+$/, "");
+    return relative === subPath || relative.startsWith(prefix);
+  };
+}
+function hoistSubPath(extractPath, subPath) {
+  if (!subPath)
+    return;
+  const landed = path2.join(extractPath, subPath);
+  if (!fs2.existsSync(landed)) {
+    throw new Error(`"${subPath}" was not found in this repository — check the path and the branch.`);
+  }
+  const staging = fs2.mkdtempSync(path2.join(path2.dirname(extractPath), ".git0-hoist-"));
+  const parked = path2.join(staging, "payload");
+  try {
+    fs2.renameSync(landed, parked);
+    fs2.rmSync(path2.join(extractPath, subPath.split("/")[0]), { recursive: true, force: true });
+    if (fs2.statSync(parked).isDirectory()) {
+      for (const child of fs2.readdirSync(parked)) {
+        fs2.renameSync(path2.join(parked, child), path2.join(extractPath, child));
+      }
+    } else {
+      fs2.renameSync(parked, path2.join(extractPath, path2.basename(subPath)));
+    }
+  } finally {
+    fs2.rmSync(staging, { recursive: true, force: true });
+  }
+}
+function subPathDirName(subPath, type) {
+  if (!subPath)
+    return;
+  const segments = subPath.split("/");
+  if (type === "blob")
+    segments.pop();
+  return segments.pop();
+}
+async function streamTarball(res, extractPath, subPath = "") {
   const { Readable } = await import("stream");
   const nodeStream = Readable.fromWeb(res);
   await new Promise((resolve, reject) => {
-    nodeStream.pipe(fo({ C: extractPath, strip: 1 })).on("finish", resolve).on("error", reject);
+    nodeStream.pipe(fo({ C: extractPath, strip: 1, filter: subPathFilter(subPath) })).on("finish", resolve).on("error", reject);
   });
 }
 async function streamToFile(res, dest) {
@@ -27340,22 +27392,31 @@ async function streamToFile(res, dest) {
     nodeStream.pipe(fs2.createWriteStream(dest)).on("finish", resolve).on("error", reject);
   });
 }
-async function downloadRepo(callGithub, repo, targetDir = null) {
+async function downloadRepo(callGithub, repo, targetDir = null, options = {}) {
   const parsed = import_git_url_parse.default(repo);
   if (parsed.owner.includes("/")) {
     parsed.owner = parsed.owner.split("/").slice(-1)[0];
   }
-  const defaultDir = path2.resolve(process.cwd(), targetDir?.length ? targetDir : parsed.name);
+  const subPath = normalizeSubPath(options.subPath);
+  const defaultName = (targetDir?.length ? targetDir : undefined) ?? subPathDirName(subPath, options.subPathType) ?? parsed.name;
+  const defaultDir = path2.resolve(process.cwd(), defaultName);
   const extractPath = getAvailableDirectoryName(defaultDir);
   fs2.mkdirSync(extractPath, { recursive: true });
-  console.log(source_default.blue(`\uD83D\uDCE6 Downloading ${parsed.name} into ${path2.basename(extractPath)}...`));
-  const defaultBranch = parsed.default_branch || "master";
+  const what = subPath ? `${parsed.name}/${subPath}` : parsed.name;
+  console.log(source_default.blue(`\uD83D\uDCE6 Downloading ${what} into ${path2.basename(extractPath)}...`));
+  const requestedRef = options.ref || parsed.ref || "";
+  const defaultBranch = requestedRef || parsed.default_branch || "master";
   const tarballUrl = `/repos/${parsed.owner}/${parsed.name}/tarball/${defaultBranch}`;
-  const params = { onStream: (res) => streamTarball(res, extractPath) };
+  const params = { onStream: (res) => streamTarball(res, extractPath, subPath) };
   let response = await callGithub(tarballUrl, params);
+  if (response.error && !requestedRef) {
+    response = await callGithub(tarballUrl.replace(/\/master$/, "/main"), params);
+  }
   if (response.error) {
-    response = await callGithub(tarballUrl.replace("/master", "/main"), params);
+    fs2.rmSync(extractPath, { recursive: true, force: true });
+    throw new Error(`Could not download ${parsed.owner}/${parsed.name}${requestedRef ? ` at ${requestedRef}` : ""}: ${response.error}`);
   }
+  hoistSubPath(extractPath, subPath);
   return extractPath;
 }
 async function downloadPackage(callGithub, packageURL, downloadPath) {
@@ -27421,6 +27482,36 @@ function printInstallInstructions(filePath, fileName) {
 }
 
 // src/github-api.ts
+function parseTarget(query) {
+  const looksLikeUrl = query.includes("github.com") || query.startsWith("git@github.com:") || query.startsWith("https://") || query.startsWith("git://");
+  if (!looksLikeUrl) {
+    const shorthand = query.match(/^([\w-]+)\/([\w.-]+)(?:\/(.+))?$/);
+    if (!shorthand)
+      return false;
+    const [, owner2, name, subPath = ""] = shorthand;
+    return {
+      owner: owner2,
+      name,
+      href: `https://github.com/${owner2}/${name}`,
+      ref: "",
+      subPath,
+      subPathType: ""
+    };
+  }
+  const parsed = import_git_url_parse2.default(query);
+  if (!parsed?.owner || !parsed?.name)
+    return false;
+  const owner = parsed.owner.includes("/") ? parsed.owner.split("/").slice(-1)[0] : parsed.owner;
+  return {
+    owner,
+    name: parsed.name,
+    href: `https://github.com/${owner}/${parsed.name}`,
+    ref: parsed.ref || "",
+    subPath: parsed.filepath || "",
+    subPathType: parsed.filepathtype || ""
+  };
+}
+
 class GithubAPI {
   static DEFAULT_RESULTS_PER_PAGE = 10;
   callGithub;
@@ -27442,8 +27533,8 @@ class GithubAPI {
       }
     });
   }
-  async downloadRepo(repo, targetDir = null) {
-    return downloadRepo(this.callGithub, repo, targetDir);
+  async downloadRepo(repo, targetDir = null, options = {}) {
+    return downloadRepo(this.callGithub, repo, targetDir, options);
   }
   async searchRepositories(query, options = {}) {
     const {
@@ -27484,6 +27575,9 @@ class GithubAPI {
   async downloadPackage(packageURL, downloadPath) {
     return downloadPackage(this.callGithub, packageURL, downloadPath);
   }
+  parseTarget(query) {
+    return parseTarget(query);
+  }
   parseURL(query) {
     if (query.includes("github.com") || query.startsWith("git@github.com:") || query.startsWith("https://") || query.startsWith("git://")) {
       return import_git_url_parse2.default(query);
@@ -27574,7 +27668,11 @@ import fs4 from "fs";
 
 // src/utils.ts
 import { execSync as execSync2 } from "child_process";
+var logoPrinted = false;
 function printLogo() {
+  if (logoPrinted)
+    return;
+  logoPrinted = true;
   console.log(source_default.cyan(`                ___
     __ _(_)‾|_ / _ \\
    / _  | | __| | | |
@@ -27716,22 +27814,151 @@ async function showPackageMenu(selectedRepo, downloadPackage2, currentPlatform)
   await downloadPackage2(selectedPackage.asset.browser_download_url, downloadPath);
 }
 
+// src/history.ts
+import { execFile } from "child_process";
+import fs6 from "fs";
+import path5 from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+async function git(args, cwd) {
+  const { stdout } = await run("git", args, { cwd, maxBuffer: 1024 * 1024 * 64 });
+  return stdout.trim();
+}
+async function gitAvailable() {
+  try {
+    await git(["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertSafeRemote(url) {
+  if (!/^(https?|git|file):\/\/[^\s]+$/.test(url)) {
+    throw new Error(`Refusing to clone from "${url}" — expected an https:// repository URL.`);
+  }
+  return url;
+}
+async function attachGitHistory(extractPath, repoUrl, options = {}) {
+  assertSafeRemote(repoUrl);
+  const gitDir = path5.join(extractPath, ".git");
+  if (fs6.existsSync(gitDir)) {
+    throw new Error(`${gitDir} already exists — not overwriting it.`);
+  }
+  if (!await gitAvailable()) {
+    throw new Error("git is not installed, so the history cannot be downloaded.");
+  }
+  const staging = fs6.mkdtempSync(path5.join(path5.dirname(extractPath), ".git0-history-"));
+  const cloned = path5.join(staging, "repo.git");
+  try {
+    await git(["clone", options.mirror ? "--mirror" : "--bare", "--quiet", repoUrl, cloned]);
+    fs6.renameSync(cloned, gitDir);
+  } catch (error) {
+    fs6.rmSync(staging, { recursive: true, force: true });
+    throw error;
+  }
+  fs6.rmSync(staging, { recursive: true, force: true });
+  await git(["config", "--local", "--bool", "core.bare", "false"], extractPath);
+  await git(["config", "--local", "--bool", "core.logallrefupdates", "true"], extractPath);
+  await git(["config", "--local", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"], extractPath);
+  await git(["fetch", "--quiet", "origin"], extractPath).catch(() => {});
+  if (options.ref) {
+    await git(["symbolic-ref", "HEAD", `refs/heads/${options.ref}`], extractPath).catch(() => {});
+  }
+  await git(["reset", "--mixed", "--quiet", "HEAD"], extractPath).catch(() => {});
+  return gitDir;
+}
+async function cloneHistoryOnly(repoUrl, targetDir, options = {}) {
+  assertSafeRemote(repoUrl);
+  if (fs6.existsSync(targetDir)) {
+    throw new Error(`${targetDir} already exists — not overwriting it.`);
+  }
+  if (!await gitAvailable()) {
+    throw new Error("git is not installed, so the history cannot be downloaded.");
+  }
+  await git(["clone", options.bare ? "--bare" : "--mirror", "--quiet", repoUrl, targetDir]);
+  return targetDir;
+}
+function attachGitHistoryLazily(extractPath, repoUrl, options = {}) {
+  console.log(source_default.blue("⏳ Fetching .git history in the background..."));
+  return attachGitHistory(extractPath, repoUrl, options).then(() => {
+    console.log(source_default.green("✅ Git history attached — `git log` is ready."));
+  }, (error) => {
+    console.log(source_default.yellow(`⚠️  Could not attach git history: ${error.message}`));
+    console.log(source_default.gray("   The downloaded source is unaffected."));
+  });
+}
+
+// src/args.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = { history: false, historyOnly: false, mirror: false };
+  for (const arg of argv) {
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const [name, ...rest] = arg.slice(2).split("=");
+    const value = rest.join("=");
+    if (name === "path")
+      flags.path = value;
+    else if (name === "branch" || name === "ref")
+      flags.branch = value;
+    else if (name === "history" || name === "git")
+      flags.history = true;
+    else if (name === "history-only" || name === "git-only")
+      flags.historyOnly = true;
+    else if (name === "mirror")
+      flags.mirror = true;
+    else
+      console.log(source_default.yellow(`Ignoring unknown flag: ${arg}`));
+  }
+  return { positional, flags };
+}
+
 // src/cli.ts
 var Github = new github_api_default({ debug: false });
-async function downloadRepoAndSetup(repo, folderPath = null) {
+async function downloadRepoAndSetup(target, folderPath = null, flags = { history: false, historyOnly: false, mirror: false }) {
   printLogo();
-  const extractPath = await Github.downloadRepo(repo, folderPath);
+  const ref = flags.branch || target.ref;
+  const extractPath = await Github.downloadRepo(target.href, folderPath, {
+    subPath: flags.path ?? target.subPath,
+    subPathType: flags.path ? "" : target.subPathType,
+    ref
+  });
+  const history = flags.history ? attachGitHistoryLazily(extractPath, target.href, { mirror: flags.mirror, ref }) : Promise.resolve();
   setTimeout(() => openInIDE(extractPath), 500);
   await installDependencies(extractPath);
+  await history;
+}
+async function downloadHistoryOnly(target, flags) {
+  printLogo();
+  const targetDir = getAvailableDirectoryName(path6.resolve(process.cwd(), `${target.name}.git`));
+  console.log(source_default.blue(`\uD83D\uDCE6 Cloning ${target.name} history into ${path6.basename(targetDir)}...`));
+  try {
+    await cloneHistoryOnly(target.href, targetDir, { bare: !flags.mirror });
+    console.log(source_default.green(`✅ History-only clone at ${targetDir}`));
+    console.log(source_default.white("  Read the log without checking anything out:"));
+    console.log(source_default.gray(`  git --git-dir="${targetDir}" log --all --oneline`));
+    console.log(source_default.white("  Or restore a working copy from it:"));
+    console.log(source_default.gray(`  git clone "${targetDir}" ${target.name}`));
+  } catch (error) {
+    console.error(source_default.red("❌ History clone failed:"), error.message);
+    process.exit(1);
+  }
 }
 function formatRepoChoice(repo) {
   const packageInfo = repo.hasCompatibleReleases ? source_default.green(" \uD83D\uDCE6 Packages available") : repo.hasReleases ? source_default.yellow(" \uD83D\uDCE6 Packages (other platforms)") : "";
   return `${source_default.bold(repo.full_name)} - ${source_default.gray(repo.description || "No description")}
 ` + `      ${source_default.yellow(`★ ${repo.stargazers_count}`)} | ${source_default.blue(repo.language || "Unknown")}${packageInfo}`;
 }
-async function handleRepoDownload(selectedRepo) {
+async function handleRepoDownload(selectedRepo, flags) {
+  const target = Github.parseTarget(selectedRepo.url);
+  if (!target) {
+    console.log(source_default.yellow(`Could not parse repository URL: ${selectedRepo.url}`));
+    return;
+  }
   if (!selectedRepo.hasReleases && !selectedRepo.hasCompatibleReleases) {
-    await downloadRepoAndSetup(selectedRepo.url);
+    await downloadRepoAndSetup(target, null, flags);
     return;
   }
   const { downloadChoice } = await esm_default12.prompt({
@@ -27748,20 +27975,29 @@ async function handleRepoDownload(selectedRepo) {
     await showPackageMenu(selectedRepo, Github.downloadPackage.bind(Github), Github.getCurrentPlatform());
   }
   if (downloadChoice === "source" || downloadChoice === "both") {
-    await downloadRepoAndSetup(selectedRepo.url);
+    await downloadRepoAndSetup(target, null, flags);
   }
 }
 async function main() {
   printLogo();
-  const args = process.argv.slice(2);
-  if (!args.length) {
-    console.log(source_default.yellow("Usage: git0 <github-url | owner/repo | search-query>"));
+  const { positional, flags } = parseArgs(process.argv.slice(2));
+  if (!positional.length) {
+    console.log(source_default.yellow("Usage: git0 <github-url | owner/repo[/path] | search-query>"));
+    console.log(source_default.gray("  --path=<path>   download only that folder or file"));
+    console.log(source_default.gray("  --branch=<ref>  download a branch, tag or commit"));
+    console.log(source_default.gray("  --history       also fetch .git history, in the background"));
+    console.log(source_default.gray("  --history-only  clone only the history, no working files"));
+    console.log(source_default.gray("  --mirror        keep every ref when cloning history"));
     process.exit(1);
   }
-  const query = args.join(" ");
-  const parsed = Github.parseURL(query);
-  if (parsed && parsed.owner && parsed.name) {
-    await downloadRepoAndSetup(parsed.href, args[1] ?? null);
+  const query = positional.join(" ");
+  const target = Github.parseTarget(query);
+  if (target) {
+    if (flags.historyOnly) {
+      await downloadHistoryOnly(target, flags);
+      return;
+    }
+    await downloadRepoAndSetup(target, positional[1] ?? null, flags);
     return;
   }
   const results = await Github.searchRepositories(query);
@@ -27775,9 +28011,12 @@ async function main() {
     message: "Select a repository to download:",
     choices: results.map((repo) => ({ name: formatRepoChoice(repo), value: repo }))
   });
-  await handleRepoDownload(selectedRepo);
+  await handleRepoDownload(selectedRepo, flags);
 }
-main();
+main().catch((error) => {
+  console.error(source_default.red(`❌ ${error.message}`));
+  process.exit(1);
+});
 
-//# debugId=5F7BB20F8A6EEFB864756E2164756E21
+//# debugId=0AD82F200D77527064756E2164756E21
 //# sourceMappingURL=cli.js.map