gistajs 0.0.0 → 0.0.2

package/README.md

@@ -0,0 +1,25 @@
+# gistajs
+
+Small CLI for creating Gista.js starter projects.
+
+## Usage
+
+```bash
+npx gistajs create my-app
+npx gistajs create my-app --starter website
+```
+
+## Development
+
+```bash
+pnpm install
+pnpm typecheck
+pnpm build
+pnpm test -- --run
+```
+
+## Release
+
+```bash
+pnpm np
+```

package/dist/bin.cjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_process3 = __toESM(require("process"), 1);
+
+// src/catalog.ts
+var DEFAULT_CATALOG_URL = "https://gistajs.com/manifests/starters.json";
+async function loadCatalog(url = DEFAULT_CATALOG_URL) {
+  let response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Catalog request failed: ${response.status}`);
+  }
+  let data = await response.json();
+  return parseCatalog(data);
+}
+function parseCatalog(data) {
+  if (!Array.isArray(data)) throw new Error("Invalid starter catalog");
+  return data.map(parseStarter);
+}
+function parseStarter(data) {
+  if (!data || typeof data !== "object") throw new Error("Invalid starter");
+  let entry = data;
+  let slug = entry.slug;
+  let repo = entry.repo;
+  let branches = entry.branches;
+  let description = entry.description;
+  if (typeof slug !== "string" || typeof repo !== "string" || typeof description !== "string") {
+    throw new Error("Invalid starter entry");
+  }
+  if (!Array.isArray(branches) || branches.length === 0 || branches.some((branch) => typeof branch !== "string" || !branch)) {
+    throw new Error(`Invalid branches for ${slug}`);
+  }
+  return { slug, repo, branches, description };
+}
+
+// src/create.ts
+var import_promises2 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_process2 = __toESM(require("process"), 1);
+var tar = __toESM(require("tar"), 1);
+
+// src/git.ts
+var import_node_child_process = require("child_process");
+
+// src/prompt.ts
+var import_node_process = __toESM(require("process"), 1);
+var import_promises = __toESM(require("readline/promises"), 1);
+async function promptForStarter(starters) {
+  let rl = createPrompt();
+  try {
+    let options = starters.map(
+      (starter2, index2) => `${index2 + 1}. ${starter2.slug} - ${starter2.description}`
+    ).join("\n");
+    let answer = await rl.question(`Choose a starter:
+${options}
+> `);
+    let index = Number.parseInt(answer.trim(), 10) - 1;
+    let starter = starters[index];
+    if (!starter) throw new Error("Invalid starter selection");
+    return starter.slug;
+  } finally {
+    rl.close();
+  }
+}
+async function promptForGitIdentity() {
+  let rl = createPrompt();
+  try {
+    console.log(
+      "Before I make the first commit, Git needs a name and email to attach to it."
+    );
+    let name = (await rl.question("Your name: ")).trim();
+    let email = (await rl.question("Your email: ")).trim();
+    if (!name) throw new Error("Name is required to make the first commit");
+    if (!email) throw new Error("Email is required to make the first commit");
+    let saveGlobal = await confirm(
+      rl,
+      "Save this as your default Git identity for future projects too? (y/N) "
+    );
+    return { name, email, saveGlobal };
+  } finally {
+    rl.close();
+  }
+}
+function createPrompt() {
+  return import_promises.default.createInterface({
+    input: import_node_process.default.stdin,
+    output: import_node_process.default.stdout
+  });
+}
+async function confirm(rl, message) {
+  let answer = (await rl.question(message)).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+// src/git.ts
+var defaultDeps = {
+  promptForGitIdentity,
+  readGitConfig,
+  run
+};
+async function initGit(root, starter, deps = defaultDeps) {
+  await git(root, ["init", "-q", "-b", "main"], deps);
+  let identity = await resolveGitIdentity(root, deps);
+  if (!identity) {
+    identity = await deps.promptForGitIdentity();
+    await git(root, ["config", "user.name", identity.name], deps);
+    await git(root, ["config", "user.email", identity.email], deps);
+    if (identity.saveGlobal) {
+      await git(root, ["config", "--global", "user.name", identity.name], deps);
+      await git(
+        root,
+        ["config", "--global", "user.email", identity.email],
+        deps
+      );
+    }
+  }
+  await git(root, ["add", "."], deps);
+  await git(
+    root,
+    ["commit", "--quiet", "-m", "Initial commit from gistajs"],
+    deps
+  );
+  for (let branch of starter.branches.slice(1)) {
+    await git(root, ["branch", branch], deps);
+  }
+  let defaultBranch = starter.branches[0];
+  if (defaultBranch && defaultBranch !== "main") {
+    await git(root, ["checkout", "-q", defaultBranch], deps);
+  }
+}
+async function git(cwd, args, deps) {
+  await deps.run("git", args, cwd);
+}
+async function resolveGitIdentity(cwd, deps) {
+  let name = deps.readGitConfig(cwd, "user.name");
+  let email = deps.readGitConfig(cwd, "user.email");
+  if (!name || !email) return null;
+  return { name, email, saveGlobal: false };
+}
+function readGitConfig(cwd, key) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["config", "--get", key], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+async function run(command, args, cwd) {
+  await new Promise((resolve2, reject) => {
+    let child = (0, import_node_child_process.spawn)(command, args, {
+      cwd,
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) resolve2();
+      else
+        reject(
+          new Error(`${command} ${args.join(" ")} exited with code ${code}`)
+        );
+    });
+  });
+}
+
+// src/create.ts
+async function createProject(starter, options) {
+  let root = (0, import_node_path.resolve)(
+    import_node_process2.default.cwd(),
+    options.targetDir || options.projectName || starter.slug
+  );
+  await assertEmptyTarget(root);
+  let staging = await (0, import_promises2.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), "gistajs-"));
+  let archivePath = (0, import_node_path.join)(staging, "starter.tgz");
+  let extractRoot = (0, import_node_path.join)(staging, "extract");
+  try {
+    await (0, import_promises2.mkdir)(extractRoot, { recursive: true });
+    await downloadStarter(starter, archivePath);
+    await extractStarter(archivePath, extractRoot);
+    let extracted = await findExtractedRoot(extractRoot);
+    await assertSafeProjectRoot(root);
+    await (0, import_promises2.rename)(extracted, root);
+    await rewritePackageName(root, (0, import_node_path.basename)(root));
+    if (options.git !== false) {
+      await initGit(root, starter);
+    }
+    if (options.install !== false) {
+      await run("pnpm", ["install"], root);
+    }
+    return root;
+  } finally {
+    await (0, import_promises2.rm)(staging, { recursive: true, force: true });
+  }
+}
+function getStarterTarballUrl(starter) {
+  let defaultBranch = starter.branches[0];
+  if (!defaultBranch) {
+    throw new Error(`Starter ${starter.slug} has no branches configured`);
+  }
+  return `https://codeload.github.com/${starter.repo}/tar.gz/refs/heads/${defaultBranch}`;
+}
+async function downloadStarter(starter, destination) {
+  let response = await fetch(getStarterTarballUrl(starter));
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download ${starter.slug} starter`);
+  }
+  let chunks = [];
+  for await (let chunk of response.body) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  await (0, import_promises2.writeFile)(destination, Buffer.concat(chunks));
+}
+async function extractStarter(archivePath, destination) {
+  await tar.x({
+    file: archivePath,
+    cwd: destination,
+    strict: true,
+    onentry: (entry) => {
+      let normalized = entry.path.replace(/\\/g, "/");
+      if (normalized.startsWith("/") || normalized.includes("../")) {
+        throw new Error(`Unsafe archive entry: ${entry.path}`);
+      }
+    }
+  });
+}
+async function findExtractedRoot(root) {
+  let children = await (0, import_promises2.readdir)(root, { withFileTypes: true });
+  let directories = children.filter((entry) => entry.isDirectory());
+  if (directories.length !== 1) {
+    throw new Error("Expected one extracted starter directory");
+  }
+  return (0, import_node_path.join)(root, directories[0].name);
+}
+async function rewritePackageName(root, projectName) {
+  let path = (0, import_node_path.join)(root, "package.json");
+  let source = await (0, import_promises2.readFile)(path, "utf8");
+  let pkg = JSON.parse(source);
+  if (typeof pkg.name === "string") {
+    pkg.name = projectName;
+    await (0, import_promises2.writeFile)(path, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+}
+async function assertEmptyTarget(root) {
+  try {
+    await (0, import_promises2.stat)(root);
+    throw new Error(`Target path already exists: ${root}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function assertSafeProjectRoot(root) {
+  let parent = (0, import_node_path.dirname)(root);
+  await (0, import_promises2.mkdir)(parent, { recursive: true });
+}
+
+// src/cli.ts
+async function runCli(argv = import_node_process3.default.argv.slice(2)) {
+  let [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command !== "create") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  let options = parseCreateArgs(rest);
+  let catalog = await loadCatalog(options.catalogUrl);
+  let starterName = options.starter || await promptForStarter(catalog);
+  let starter = catalog.find((entry) => entry.slug === starterName);
+  if (!starter) {
+    throw new Error(`Unknown starter: ${starterName}`);
+  }
+  if (!options.projectName) {
+    throw new Error("Project name is required");
+  }
+  let root = await createProject(starter, options);
+  console.log(`Created ${starter.slug} project in ${root}`);
+}
+async function main() {
+  try {
+    await runCli();
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    import_node_process3.default.exitCode = 1;
+  }
+}
+function parseCreateArgs(argv) {
+  let options = {
+    install: true,
+    git: true
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    let arg = argv[index];
+    if (!arg) continue;
+    if (!arg.startsWith("--") && !options.projectName) {
+      options.projectName = arg;
+      continue;
+    }
+    if (arg === "--starter") {
+      if (!argv[index + 1]) throw new Error("--starter requires a value");
+      options.starter = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--no-install") {
+      options.install = false;
+      continue;
+    }
+    if (arg === "--no-git") {
+      options.git = false;
+      continue;
+    }
+    if (arg === "--catalog-url") {
+      if (!argv[index + 1]) throw new Error("--catalog-url requires a value");
+      options.catalogUrl = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return options;
+}
+function printHelp() {
+  console.log(
+    [
+      "Usage:",
+      "  gistajs create <project-name> [--starter <slug>] [--no-install] [--no-git]"
+    ].join("\n")
+  );
+}
+
+// src/bin.ts
+void main();

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+type StarterSpec = {
+    slug: string;
+    repo: string;
+    branches: string[];
+    description: string;
+};
+type CreateOptions = {
+    projectName?: string;
+    starter?: string;
+    targetDir?: string;
+    install?: boolean;
+    git?: boolean;
+    catalogUrl?: string;
+};
+
+declare function runCli(argv?: string[]): Promise<void>;
+
+declare function createProject(starter: StarterSpec, options: CreateOptions): Promise<string>;
+
+export { type CreateOptions, type StarterSpec, createProject, runCli };

package/dist/index.js

@@ -0,0 +1,336 @@
+// src/cli.ts
+import process3 from "process";
+
+// src/catalog.ts
+var DEFAULT_CATALOG_URL = "https://gistajs.com/manifests/starters.json";
+async function loadCatalog(url = DEFAULT_CATALOG_URL) {
+  let response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Catalog request failed: ${response.status}`);
+  }
+  let data = await response.json();
+  return parseCatalog(data);
+}
+function parseCatalog(data) {
+  if (!Array.isArray(data)) throw new Error("Invalid starter catalog");
+  return data.map(parseStarter);
+}
+function parseStarter(data) {
+  if (!data || typeof data !== "object") throw new Error("Invalid starter");
+  let entry = data;
+  let slug = entry.slug;
+  let repo = entry.repo;
+  let branches = entry.branches;
+  let description = entry.description;
+  if (typeof slug !== "string" || typeof repo !== "string" || typeof description !== "string") {
+    throw new Error("Invalid starter entry");
+  }
+  if (!Array.isArray(branches) || branches.length === 0 || branches.some((branch) => typeof branch !== "string" || !branch)) {
+    throw new Error(`Invalid branches for ${slug}`);
+  }
+  return { slug, repo, branches, description };
+}
+
+// src/create.ts
+import {
+  mkdtemp,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname, join, resolve } from "path";
+import process2 from "process";
+import * as tar from "tar";
+
+// src/git.ts
+import { execFileSync, spawn } from "child_process";
+
+// src/prompt.ts
+import process from "process";
+import readline from "readline/promises";
+async function promptForStarter(starters) {
+  let rl = createPrompt();
+  try {
+    let options = starters.map(
+      (starter2, index2) => `${index2 + 1}. ${starter2.slug} - ${starter2.description}`
+    ).join("\n");
+    let answer = await rl.question(`Choose a starter:
+${options}
+> `);
+    let index = Number.parseInt(answer.trim(), 10) - 1;
+    let starter = starters[index];
+    if (!starter) throw new Error("Invalid starter selection");
+    return starter.slug;
+  } finally {
+    rl.close();
+  }
+}
+async function promptForGitIdentity() {
+  let rl = createPrompt();
+  try {
+    console.log(
+      "Before I make the first commit, Git needs a name and email to attach to it."
+    );
+    let name = (await rl.question("Your name: ")).trim();
+    let email = (await rl.question("Your email: ")).trim();
+    if (!name) throw new Error("Name is required to make the first commit");
+    if (!email) throw new Error("Email is required to make the first commit");
+    let saveGlobal = await confirm(
+      rl,
+      "Save this as your default Git identity for future projects too? (y/N) "
+    );
+    return { name, email, saveGlobal };
+  } finally {
+    rl.close();
+  }
+}
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function confirm(rl, message) {
+  let answer = (await rl.question(message)).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+
+// src/git.ts
+var defaultDeps = {
+  promptForGitIdentity,
+  readGitConfig,
+  run
+};
+async function initGit(root, starter, deps = defaultDeps) {
+  await git(root, ["init", "-q", "-b", "main"], deps);
+  let identity = await resolveGitIdentity(root, deps);
+  if (!identity) {
+    identity = await deps.promptForGitIdentity();
+    await git(root, ["config", "user.name", identity.name], deps);
+    await git(root, ["config", "user.email", identity.email], deps);
+    if (identity.saveGlobal) {
+      await git(root, ["config", "--global", "user.name", identity.name], deps);
+      await git(
+        root,
+        ["config", "--global", "user.email", identity.email],
+        deps
+      );
+    }
+  }
+  await git(root, ["add", "."], deps);
+  await git(
+    root,
+    ["commit", "--quiet", "-m", "Initial commit from gistajs"],
+    deps
+  );
+  for (let branch of starter.branches.slice(1)) {
+    await git(root, ["branch", branch], deps);
+  }
+  let defaultBranch = starter.branches[0];
+  if (defaultBranch && defaultBranch !== "main") {
+    await git(root, ["checkout", "-q", defaultBranch], deps);
+  }
+}
+async function git(cwd, args, deps) {
+  await deps.run("git", args, cwd);
+}
+async function resolveGitIdentity(cwd, deps) {
+  let name = deps.readGitConfig(cwd, "user.name");
+  let email = deps.readGitConfig(cwd, "user.email");
+  if (!name || !email) return null;
+  return { name, email, saveGlobal: false };
+}
+function readGitConfig(cwd, key) {
+  try {
+    return execFileSync("git", ["config", "--get", key], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+async function run(command, args, cwd) {
+  await new Promise((resolve2, reject) => {
+    let child = spawn(command, args, {
+      cwd,
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) resolve2();
+      else
+        reject(
+          new Error(`${command} ${args.join(" ")} exited with code ${code}`)
+        );
+    });
+  });
+}
+
+// src/create.ts
+async function createProject(starter, options) {
+  let root = resolve(
+    process2.cwd(),
+    options.targetDir || options.projectName || starter.slug
+  );
+  await assertEmptyTarget(root);
+  let staging = await mkdtemp(join(tmpdir(), "gistajs-"));
+  let archivePath = join(staging, "starter.tgz");
+  let extractRoot = join(staging, "extract");
+  try {
+    await mkdir(extractRoot, { recursive: true });
+    await downloadStarter(starter, archivePath);
+    await extractStarter(archivePath, extractRoot);
+    let extracted = await findExtractedRoot(extractRoot);
+    await assertSafeProjectRoot(root);
+    await rename(extracted, root);
+    await rewritePackageName(root, basename(root));
+    if (options.git !== false) {
+      await initGit(root, starter);
+    }
+    if (options.install !== false) {
+      await run("pnpm", ["install"], root);
+    }
+    return root;
+  } finally {
+    await rm(staging, { recursive: true, force: true });
+  }
+}
+function getStarterTarballUrl(starter) {
+  let defaultBranch = starter.branches[0];
+  if (!defaultBranch) {
+    throw new Error(`Starter ${starter.slug} has no branches configured`);
+  }
+  return `https://codeload.github.com/${starter.repo}/tar.gz/refs/heads/${defaultBranch}`;
+}
+async function downloadStarter(starter, destination) {
+  let response = await fetch(getStarterTarballUrl(starter));
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download ${starter.slug} starter`);
+  }
+  let chunks = [];
+  for await (let chunk of response.body) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  await writeFile(destination, Buffer.concat(chunks));
+}
+async function extractStarter(archivePath, destination) {
+  await tar.x({
+    file: archivePath,
+    cwd: destination,
+    strict: true,
+    onentry: (entry) => {
+      let normalized = entry.path.replace(/\\/g, "/");
+      if (normalized.startsWith("/") || normalized.includes("../")) {
+        throw new Error(`Unsafe archive entry: ${entry.path}`);
+      }
+    }
+  });
+}
+async function findExtractedRoot(root) {
+  let children = await readdir(root, { withFileTypes: true });
+  let directories = children.filter((entry) => entry.isDirectory());
+  if (directories.length !== 1) {
+    throw new Error("Expected one extracted starter directory");
+  }
+  return join(root, directories[0].name);
+}
+async function rewritePackageName(root, projectName) {
+  let path = join(root, "package.json");
+  let source = await readFile(path, "utf8");
+  let pkg = JSON.parse(source);
+  if (typeof pkg.name === "string") {
+    pkg.name = projectName;
+    await writeFile(path, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+}
+async function assertEmptyTarget(root) {
+  try {
+    await stat(root);
+    throw new Error(`Target path already exists: ${root}`);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function assertSafeProjectRoot(root) {
+  let parent = dirname(root);
+  await mkdir(parent, { recursive: true });
+}
+
+// src/cli.ts
+async function runCli(argv = process3.argv.slice(2)) {
+  let [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command !== "create") {
+    throw new Error(`Unknown command: ${command}`);
+  }
+  let options = parseCreateArgs(rest);
+  let catalog = await loadCatalog(options.catalogUrl);
+  let starterName = options.starter || await promptForStarter(catalog);
+  let starter = catalog.find((entry) => entry.slug === starterName);
+  if (!starter) {
+    throw new Error(`Unknown starter: ${starterName}`);
+  }
+  if (!options.projectName) {
+    throw new Error("Project name is required");
+  }
+  let root = await createProject(starter, options);
+  console.log(`Created ${starter.slug} project in ${root}`);
+}
+function parseCreateArgs(argv) {
+  let options = {
+    install: true,
+    git: true
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    let arg = argv[index];
+    if (!arg) continue;
+    if (!arg.startsWith("--") && !options.projectName) {
+      options.projectName = arg;
+      continue;
+    }
+    if (arg === "--starter") {
+      if (!argv[index + 1]) throw new Error("--starter requires a value");
+      options.starter = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--no-install") {
+      options.install = false;
+      continue;
+    }
+    if (arg === "--no-git") {
+      options.git = false;
+      continue;
+    }
+    if (arg === "--catalog-url") {
+      if (!argv[index + 1]) throw new Error("--catalog-url requires a value");
+      options.catalogUrl = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  return options;
+}
+function printHelp() {
+  console.log(
+    [
+      "Usage:",
+      "  gistajs create <project-name> [--starter <slug>] [--no-install] [--no-git]"
+    ].join("\n")
+  );
+}
+export {
+  createProject,
+  runCli
+};

package/package.json

@@ -1 +1,55 @@
-{"name":"gistajs","version":"0.0.0"}
+{
+  "name": "gistajs",
+  "version": "0.0.2",
+  "description": "Create Gista.js starter projects",
+  "keywords": [
+    "cli",
+    "gistajs",
+    "scaffold",
+    "starter"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Kenn Ejima",
+    "email": "kenn@users.noreply.github.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gistajs/gistajs.git"
+  },
+  "bin": {
+    "gistajs": "dist/bin.cjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "tar": "^7.5.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "np": "^11.0.2",
+    "oxfmt": "^0.40.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "typecheck": "tsc -b",
+    "np": "np"
+  }
+}

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto