@rathnasgala/cli 0.0.21 → 1.0.0

package/src/record-deployment-command.js

@@ -1,147 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { lstat } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import { parseFrontmatter } from '@rathnasgala/content-validation';
-
-import { repositoryEvaluationDate } from './evaluation-date.js';
-import { recordSuccessfulDeployment } from './publication-state.js';
-import { BUILD_MANIFEST_PATH } from './validate-command.js';
-
-function runGit(root, args, spawnProcess) {
-  return new Promise((resolve, reject) => {
-    const child = spawnProcess('git', ['-C', root, ...args], {
-      cwd: root,
-      shell: false,
-      stdio: 'inherit'
-    });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) reject(new Error(`Git terminated by signal ${signal}`));
-      else resolve(code);
-    });
-  });
-}
-
-function readHead(root, spawnProcess) {
-  return new Promise((resolve, reject) => {
-    const child = spawnProcess('git', ['-C', root, 'rev-parse', '--verify', 'HEAD'], {
-      cwd: root,
-      shell: false,
-      stdio: ['ignore', 'pipe', 'inherit']
-    });
-    let output = '';
-    child.stdout?.on('data', (chunk) => { output += chunk; });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) reject(new Error(`Git terminated by signal ${signal}`));
-      else if (code !== 0) reject(new Error(`Git rev-parse exited with code ${code}`));
-      else {
-        const sha = output.trim();
-        if (!/^[0-9a-f]{40}$/.test(sha)) reject(new Error('Git returned an invalid HEAD SHA'));
-        else resolve(sha);
-      }
-    });
-  });
-}
-
-async function assignedContentPaths(root, manifest) {
-  const assigned = manifest.assignedContentIds ?? [];
-  if (!Array.isArray(assigned)) throw new TypeError('assignedContentIds must be a list');
-  const sources = new Set();
-  for (const item of assigned) {
-    if (item == null
-        || typeof item.source !== 'string'
-        || !/^content\/posts\/[a-z0-9]+(?:-[a-z0-9]+)*\/index\.[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*\.md$/.test(item.source)
-        || typeof item.id !== 'string'
-        || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/.test(item.id)
-        || typeof item.fileHash !== 'string'
-        || !/^[a-f0-9]{64}$/.test(item.fileHash)
-        || sources.has(item.source)) {
-      throw new TypeError('assignedContentIds contains an invalid entry');
-    }
-    const file = path.resolve(root, item.source);
-    const metadata = await lstat(file);
-    if (!metadata.isFile() || metadata.isSymbolicLink()) {
-      throw new TypeError(`Assigned-ID source must be a regular file: ${item.source}`);
-    }
-    const bytes = await readFile(file);
-    if (createHash('sha256').update(bytes).digest('hex') !== item.fileHash) {
-      throw new Error(`Assigned-ID source changed after the deployed build: ${item.source}`);
-    }
-    const parsed = parseFrontmatter(bytes.toString('utf8'));
-    if (parsed.errors.length > 0 || parsed.data.id !== item.id) {
-      throw new Error(`Assigned-ID source no longer contains its deployed ULID: ${item.source}`);
-    }
-    sources.add(item.source);
-  }
-  return [...sources].sort();
-}
-
-export async function recordDeployment({
-  root,
-  deployedOn,
-  now,
-  deployedCommitSha,
-  spawnProcess = spawn
-}) {
-  const siteRoot = path.resolve(root);
-  const manifestPath = path.join(siteRoot, BUILD_MANIFEST_PATH);
-  let manifest;
-  try {
-    manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      throw new Error('Current validated build manifest is missing; deployment cannot be recorded');
-    }
-    throw new TypeError(`Current validated build manifest is invalid: ${error.message}`);
-  }
-  const date = deployedOn ?? await repositoryEvaluationDate({ root: siteRoot, now });
-  if (typeof deployedCommitSha !== 'string' || !/^[0-9a-f]{40}$/.test(deployedCommitSha)) {
-    throw new TypeError('record-deployment requires --commit-sha <lowercase 40-character SHA>');
-  }
-  const head = await readHead(siteRoot, spawnProcess);
-  if (deployedCommitSha !== head) {
-    throw new Error(`Deployment SHA ${deployedCommitSha} does not match checkout HEAD ${head}`);
-  }
-  const state = await recordSuccessfulDeployment({
-    root: siteRoot,
-    manifest,
-    deployedOn: date,
-    deployedCommitSha
-  });
-  const statePath = '.gala/publication-state.yml';
-  const contentPaths = await assignedContentPaths(siteRoot, manifest);
-  const committedPaths = [statePath, ...contentPaths];
-  const addCode = await runGit(siteRoot, ['add', '--', ...committedPaths], spawnProcess);
-  if (addCode !== 0) throw new Error(`Git add exited with code ${addCode}`);
-  const diffCode = await runGit(
-    siteRoot,
-    ['diff', '--cached', '--quiet', '--exit-code', '--', ...committedPaths],
-    spawnProcess
-  );
-  if (diffCode === 0) return { state, pushed: false, recordedStateSha: head };
-  if (diffCode !== 1) throw new Error(`Git diff exited with code ${diffCode}`);
-  const assignmentTrailers = (manifest.assignedContentIds ?? []).map(
-    ({ id, source }) => `Gala-Assigned-ID: ${id} ${source}`
-  );
-  const commitMessage = [
-    'chore(gala): record successful deployment [skip ci]',
-    '',
-    `Gala-Deployed-SHA: ${deployedCommitSha}`,
-    ...assignmentTrailers
-  ].join('\n');
-  const commitCode = await runGit(siteRoot, [
-    'commit', '--only', '-m', commitMessage,
-    '--', ...committedPaths
-  ], spawnProcess);
-  if (commitCode !== 0) throw new Error(`Git commit exited with code ${commitCode}`);
-  const recordedStateSha = await readHead(siteRoot, spawnProcess);
-  if (recordedStateSha === deployedCommitSha) {
-    throw new Error('Git did not create a distinct recorded-state commit');
-  }
-  const pushCode = await runGit(siteRoot, ['push'], spawnProcess);
-  if (pushCode !== 0) throw new Error(`Git push exited with code ${pushCode}`);
-  return { state, pushed: true, recordedStateSha };
-}

package/src/refresh-command.js

@@ -1,104 +0,0 @@
-import { lstat, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { parse } from 'yaml';
-
-import { readGalaCredential } from './gala-credential-store.js';
-
-const ULID = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
-const UTC_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
-const SNAPSHOT_PATH = '.engagement-snapshot.json';
-
-async function runGit(root, args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn('git', ['-C', root, ...args], { shell: false, stdio: 'inherit' });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) reject(new Error(`git terminated by signal ${signal}`));
-      else if (code !== 0) reject(new Error(`git ${args[0]} exited with code ${code}`));
-      else resolve();
-    });
-  });
-}
-
-async function commitRefreshedSnapshot(root, relativePath) {
-  await runGit(root, [
-    'commit', '--only', '--message', 'chore(gala): refresh engagement snapshot', '--', relativePath
-  ]);
-  await runGit(root, ['push']);
-}
-
-function validateSnapshot(payload) {
-  if (payload?.schemaVersion !== 1 || !UTC_INSTANT.test(payload.refreshedAt)
-      || payload.articles == null || Array.isArray(payload.articles)
-      || typeof payload.articles !== 'object') {
-    throw new TypeError('Engagement snapshot response is invalid');
-  }
-  for (const [articleId, counts] of Object.entries(payload.articles)) {
-    if (!ULID.test(articleId) || counts == null || Array.isArray(counts)
-        || typeof counts !== 'object'
-        || Object.keys(counts).sort().join(',') !== 'comments,reactions,views'
-        || !['reactions', 'comments', 'views'].every(
-          (field) => Number.isSafeInteger(counts[field]) && counts[field] >= 0
-        )) {
-      throw new TypeError('Engagement snapshot response is invalid');
-    }
-  }
-  return payload;
-}
-
-async function requireRegularFile(target, label, { allowMissing = false } = {}) {
-  try {
-    const metadata = await lstat(target);
-    if (!metadata.isFile() || metadata.isSymbolicLink()) {
-      throw new TypeError(`${label} must be a regular file`);
-    }
-    return true;
-  } catch (error) {
-    if (allowMissing && error.code === 'ENOENT') return false;
-    throw error;
-  }
-}
-
-export async function refreshEngagementSnapshot({
-  root = process.cwd(),
-  readCredential = readGalaCredential,
-  fetchImpl = fetch,
-  commitSnapshot = commitRefreshedSnapshot
-} = {}) {
-  const siteRoot = path.resolve(root);
-  const configPath = path.join(siteRoot, 'site.config.yml');
-  await requireRegularFile(configPath, 'site.config.yml');
-  const config = parse(await readFile(configPath, 'utf8'));
-  const siteId = config?.site?.id;
-  if (!ULID.test(siteId)) throw new TypeError('site.config.yml site.id must be a canonical ULID');
-
-  const credential = await readCredential();
-  const endpoint = new URL(`/v1/sites/${siteId}/engagement-snapshot`, credential.apiBaseUrl);
-  const loopback = endpoint.protocol === 'http:'
-    && ['127.0.0.1', 'localhost', '::1'].includes(endpoint.hostname);
-  if ((endpoint.protocol !== 'https:' && !loopback) || endpoint.username || endpoint.password) {
-    throw new TypeError('Gala API URL must be credential-free HTTPS or HTTP loopback');
-  }
-  const response = await fetchImpl(endpoint, {
-    method: 'GET',
-    headers: { Authorization: `Bearer ${credential.accessToken}`, Accept: 'application/json' }
-  });
-  if (!response.ok) throw new Error(`Engagement snapshot refresh failed with HTTP ${response.status}`);
-  const snapshot = validateSnapshot(await response.json());
-  const next = `${JSON.stringify(snapshot, null, 2)}\n`;
-  const target = path.join(siteRoot, SNAPSHOT_PATH);
-  const exists = await requireRegularFile(target, 'Engagement snapshot', { allowMissing: true });
-  if (exists && await readFile(target, 'utf8') === next) return Object.freeze({ changed: false });
-
-  const temporary = `${target}.gala-${process.pid}`;
-  try {
-    await writeFile(temporary, next, { flag: 'wx' });
-    await rename(temporary, target);
-  } catch (error) {
-    await rm(temporary, { force: true });
-    throw error;
-  }
-  await commitSnapshot(siteRoot, SNAPSHOT_PATH);
-  return Object.freeze({ changed: true });
-}

package/src/repository-limits.js

@@ -1,94 +0,0 @@
-import { spawn } from 'node:child_process';
-import { lstat, readdir } from 'node:fs/promises';
-import path from 'node:path';
-
-const MEBIBYTE = 1024 * 1024;
-
-function gitRepositoryBytes(root, spawnProcess) {
-  return new Promise((resolve, reject) => {
-    const child = spawnProcess('git', ['-C', root, 'count-objects', '-v'], {
-      cwd: root,
-      shell: false,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-    let output = '';
-    let errors = '';
-    child.stdout.on('data', (chunk) => { output += chunk; });
-    child.stderr.on('data', (chunk) => { errors += chunk; });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) return reject(new Error(`Repository inspection terminated by signal ${signal}`));
-      if (code !== 0) return reject(new Error(`Repository inspection failed: ${errors.trim()}`));
-      const values = Object.fromEntries(output.trim().split('\n').map((line) => {
-        const separator = line.indexOf(':');
-        return [line.slice(0, separator), Number(line.slice(separator + 1).trim())];
-      }));
-      if (!Number.isFinite(values.size) || !Number.isFinite(values['size-pack'])) {
-        return reject(new Error('Git returned invalid repository size metadata'));
-      }
-      resolve((values.size + values['size-pack']) * 1024);
-    });
-  });
-}
-
-async function countPosts(directory) {
-  const entries = await readdir(directory, { withFileTypes: true });
-  const counts = await Promise.all(entries.map((entry) => {
-    if (entry.isDirectory()) return countPosts(path.join(directory, entry.name));
-    return Promise.resolve(entry.isFile() && /^index\.[^.]+\.md$/.test(entry.name) ? 1 : 0);
-  }));
-  return counts.reduce((total, count) => total + count, 0);
-}
-
-export function repositoryLimitWarnings({ repositoryBytes, postCount, buildDurationMs }) {
-  const warnings = [];
-  if (repositoryBytes > 800 * MEBIBYTE) {
-    warnings.push({ severity: 'critical', code: 'repository-size-800mb' });
-  } else if (repositoryBytes > 500 * MEBIBYTE) {
-    warnings.push({ severity: 'warning', code: 'repository-size-500mb' });
-  }
-  if (postCount > 1000) warnings.push({ severity: 'warning', code: 'post-count-1000' });
-  if (buildDurationMs != null && buildDurationMs > 5 * 60 * 1000) {
-    warnings.push({ severity: 'warning', code: 'build-duration-5m' });
-  }
-  return warnings;
-}
-
-export async function inspectRepositoryLimits(root, { spawnProcess = spawn, buildDurationMs } = {}) {
-  const resolvedRoot = path.resolve(root);
-  const [repositoryBytes, postCount] = await Promise.all([
-    gitRepositoryBytes(resolvedRoot, spawnProcess),
-    countPosts(path.join(resolvedRoot, 'content', 'posts'))
-  ]);
-  return {
-    repositoryBytes,
-    postCount,
-    warnings: repositoryLimitWarnings({ repositoryBytes, postCount, buildDurationMs })
-  };
-}
-
-export async function reportRepositoryLimitWarnings(
-  root,
-  { spawnProcess = spawn, output = process.stderr } = {}
-) {
-  const resolvedRoot = path.resolve(root);
-  try {
-    const [gitMetadata, config, posts] = await Promise.all([
-      lstat(path.join(resolvedRoot, '.git')),
-      lstat(path.join(resolvedRoot, 'site.config.yml')),
-      lstat(path.join(resolvedRoot, 'content', 'posts'))
-    ]);
-    if ((!gitMetadata.isDirectory() && !gitMetadata.isFile())
-      || !config.isFile() || config.isSymbolicLink()
-      || !posts.isDirectory() || posts.isSymbolicLink()) {
-      return [];
-    }
-  } catch (error) {
-    if (error.code === 'ENOENT') return [];
-    throw error;
-  }
-
-  const { warnings } = await inspectRepositoryLimits(resolvedRoot, { spawnProcess });
-  for (const { severity, code } of warnings) output.write(`${severity}\t${code}\n`);
-  return warnings;
-}

package/src/scaffold-git.js

@@ -1,41 +0,0 @@
-import { spawn } from 'node:child_process';
-
-function run(root, args, spawnProcess, acceptedExitCodes = [0]) {
-  return new Promise((resolve, reject) => {
-    const child = spawnProcess('git', ['-C', root, ...args], { cwd: root, shell: false, stdio: 'inherit' });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) reject(new Error(`Git ${args[0]} terminated by signal ${signal}`));
-      else if (!acceptedExitCodes.includes(code)) reject(new Error(`Git ${args[0]} exited with code ${code}`));
-      else resolve(code);
-    });
-  });
-}
-
-function capture(root, args, spawnProcess) {
-  return new Promise((resolve, reject) => {
-    const child = spawnProcess('git', ['-C', root, ...args], {
-      cwd: root, shell: false, stdio: ['ignore', 'pipe', 'inherit']
-    });
-    let stdout = '';
-    child.stdout.on('data', (chunk) => { stdout += chunk; });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (signal) reject(new Error(`Git ${args[0]} terminated by signal ${signal}`));
-      else if (code !== 0) reject(new Error(`Git ${args[0]} exited with code ${code}`));
-      else resolve(stdout.trim());
-    });
-  });
-}
-
-export async function commitScaffold(root, { spawnProcess = spawn } = {}) {
-  await run(root, ['add', '--', 'site.config.yml', '.github/workflows/publish.yml'], spawnProcess);
-  const unchanged = await run(root, ['diff', '--cached', '--quiet', '--exit-code'], spawnProcess, [0, 1]);
-  if (unchanged === 1) {
-    await run(root, ['commit', '-m', 'chore(gala): configure site'], spawnProcess);
-  }
-  await run(root, ['push', 'origin', 'HEAD'], spawnProcess);
-  const commitSha = await capture(root, ['rev-parse', 'HEAD'], spawnProcess);
-  if (!/^[0-9a-f]{40}$/.test(commitSha)) throw new Error('Git returned an invalid scaffold commit SHA');
-  return commitSha;
-}

package/src/scaffold-options.js

@@ -1,58 +0,0 @@
-export const scaffoldOptionNames = Object.freeze([
-  'theme',
-  'layout',
-  'palette',
-  'typography',
-  'spacing',
-  'radius',
-  'density',
-  'motion',
-  'componentStyle'
-]);
-
-const singleValueOptions = Object.freeze({
-  'site-name': 'siteName',
-  author: 'siteAuthor',
-  language: 'defaultLanguage',
-  timezone: 'timezone'
-});
-
-function requireValue(args, index, name) {
-  const value = args[index + 1];
-  if (!value || value.startsWith('--')) {
-    throw new Error(`Missing value for --${name}`);
-  }
-  return value;
-}
-
-export function parseScaffoldOptions(args) {
-  const values = {};
-
-  for (let index = 0; index < args.length; index += 1) {
-    const argument = args[index];
-    if (!argument.startsWith('--')) continue;
-
-    const name = argument.slice(2);
-    if (name === 'share-target') {
-      const value = requireValue(args, index, name);
-      values.shareTargets = [...(values.shareTargets ?? []), value];
-      index += 1;
-      continue;
-    }
-    if (name === 'social-profile') {
-      const value = requireValue(args, index, name);
-      values.socialProfiles = [...(values.socialProfiles ?? []), value];
-      index += 1;
-      continue;
-    }
-
-    const targetName = singleValueOptions[name] ?? name;
-    if (!scaffoldOptionNames.includes(name) && singleValueOptions[name] == null) continue;
-
-    const value = requireValue(args, index, name);
-    values[targetName] = value;
-    index += 1;
-  }
-
-  return values;
-}

package/src/scaffold-preflight.js

@@ -1,147 +0,0 @@
-import path from 'node:path';
-
-import { authenticateGala } from './auth-command.js';
-import { authenticateGithub } from './github-auth-command.js';
-import { readGalaCredential } from './gala-credential-store.js';
-import { readGithubCredential } from './github-credential-store.js';
-import { resolveGithubLogin } from './github-identity.js';
-import { galaCredentialAccepted } from './gala-credential-health.js';
-import { openInBrowser } from './open-browser.js';
-import { forgetGalaCredential } from './gala-credential-store.js';
-
-export const GITHUB_APP_INSTALL_URL = 'https://github.com/apps/gala67-app/installations/new';
-
-const DEFAULT_API_BASE_URL = 'https://api.gala67.com';
-
-/**
- * Everything `scaffold` needs, worked out rather than demanded.
- *
- * `scaffold` used to require four values up front — `--owner`, `--repository`, `--target` and
- * `--installation-id` — and it failed outright if `auth` or `auth github` had not been run first,
- * telling the writer to go and run them. Three of those four are derivable and the two sign-ins
- * can simply happen. Every one of them is still accepted as an explicit override; nothing that
- * worked before stops working.
- *
- * The steps are ordered so nothing is created until everything is known: the App installation is
- * confirmed before a repository exists, rather than after, so an interrupted run leaves no
- * half-connected repository behind.
- */
-export async function prepareScaffold({
-  owner,
-  repository,
-  target,
-  githubInstallationId,
-  siteName,
-  cwd = process.cwd(),
-  notify = () => {},
-  ask,
-  openUrl = openInBrowser,
-  readGala = readGalaCredential,
-  readGithub = readGithubCredential,
-  credentialAccepted = galaCredentialAccepted,
-  forgetGala = forgetGalaCredential,
-  signInGala = authenticateGala,
-  signInGithub = authenticateGithub,
-  resolveLogin = resolveGithubLogin,
-  apiBaseUrl = DEFAULT_API_BASE_URL
-} = {}) {
-  const gala = await ensureGala({
-    apiBaseUrl, notify, readGala, signInGala, credentialAccepted, forgetGala, openUrl
-  });
-  const github = await ensureGithub({ notify, readGithub, signInGithub, openUrl });
-
-  const resolvedOwner = owner ?? await resolveLogin({ accessToken: github.accessToken });
-
-  const resolvedRepository = repository
-    ?? (target == null ? null : path.basename(path.resolve(cwd, target)))
-    ?? repositoryNameFrom(siteName)
-    ?? await askForRepository(ask);
-
-  // `--target ./` is the common case and means "here", so the repository takes its name from the
-  // directory the writer is standing in. Everywhere else the repository names its own folder.
-  const resolvedTarget = target ?? `./${resolvedRepository}`;
-
-  /*
-   * No installation lookup. The id is an internal GitHub identifier for an App the server owns, and
-   * nothing here can discover it reliably: a GitHub App token could list installations and the CLI
-   * cannot hold one, while the repository inventory only carries the id once a repository exists —
-   * which, in the flow that creates the first repository, is never. The server resolves it during
-   * registration. `--installation-id` still overrides, for an account with several.
-   */
-  return Object.freeze({
-    owner: resolvedOwner,
-    repository: resolvedRepository,
-    target: resolvedTarget,
-    githubInstallationId: githubInstallationId ?? null
-  });
-}
-
-/**
- * A missing, expired or refused credential is a step to take, not an error to report.
- *
- * The stored file is checked against the server before anything depends on it, because a
- * credential that parses and has not expired can still be one the API refuses — and finding that
- * out four calls later, as an opaque 401 from whichever endpoint got there first, is how a
- * "sign in again" turned into a stack trace.
- */
-async function ensureGala({
-  apiBaseUrl, notify, readGala, signInGala, credentialAccepted, forgetGala, openUrl
-}) {
-  let stored = null;
-  try {
-    stored = await readGala();
-  } catch {
-    stored = null;
-  }
-
-  if (stored != null) {
-    const base = stored.apiBaseUrl ?? apiBaseUrl;
-    if (await credentialAccepted({ apiBaseUrl: base, accessToken: stored.accessToken })) {
-      return stored;
-    }
-    // Leaving it on disk would make every later command repeat this discovery.
-    await forgetGala();
-    notify('Your Gala sign-in is no longer valid.');
-  }
-
-  notify('Signing in to Gala.');
-  await signInGala({
-    apiBaseUrl,
-    showInstructions: ({ verificationUri, userCode }) =>
-      notify(`${openUrl(verificationUri) ? 'Opened' : 'Open'} ${verificationUri}\nEnter code: ${userCode}`)
-  });
-  return readGala();
-}
-
-async function ensureGithub({ notify, readGithub, signInGithub, openUrl }) {
-  try {
-    return await readGithub();
-  } catch {
-    notify('Signing in to GitHub.');
-    await signInGithub({
-      showScopeWarning: ({ explanation }) => notify(`GitHub authorization: ${explanation}`),
-      showInstructions: ({ verificationUri, userCode }) =>
-        notify(`${openUrl(verificationUri) ? 'Opened' : 'Open'} ${verificationUri}\nEnter code: ${userCode}`)
-    });
-    return readGithub();
-  }
-}
-
-/** GitHub repository names allow letters, digits, dot, underscore and hyphen, and nothing else. */
-export function repositoryNameFrom(siteName) {
-  if (typeof siteName !== 'string') return null;
-  const slug = siteName
-    .trim().toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return slug === '' ? null : slug;
-}
-
-async function askForRepository(ask) {
-  if (typeof ask !== 'function') {
-    throw new TypeError('repository is required; pass --repository or --site-name');
-  }
-  const answer = repositoryNameFrom(await ask('What should the publication repository be called? '));
-  if (answer == null) throw new TypeError('A repository name is required');
-  return answer;
-}