@ajaykumarnpm/talea 0.1.0

package/src/update.js

@@ -0,0 +1,119 @@
+// Update checking and self-upgrade.
+//
+// Deliberately NOT a silent auto-updater. This tool moves checkouts around;
+// changing its own behaviour mid-session without the developer knowing is how
+// you get an unreproducible bug report. So: a passive, cached, once-a-day
+// notice plus an explicit `talea upgrade`.
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { readUserState, writeUserState } from './config.js';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.join(here, '..');
+
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const CHECK_TIMEOUT_MS = 3000;
+
+export const pkgJson = () =>
+  JSON.parse(readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+
+/**
+ * How this copy was installed, which decides whether upgrading is ours to do.
+ *   'local' — a git checkout (npm link, or run straight from source)
+ *   'npm'   — installed from the registry
+ */
+export function installKind() {
+  return existsSync(path.join(PACKAGE_ROOT, '.git')) ? 'local' : 'npm';
+}
+
+/** Compare semver-ish strings. Returns true when `b` is newer than `a`. */
+export function isNewer(a, b) {
+  const parse = (v) =>
+    String(v)
+      .replace(/^v/, '')
+      .split('-')[0]
+      .split('.')
+      .map((n) => parseInt(n, 10) || 0);
+  const [x, y] = [parse(a), parse(b)];
+  for (let i = 0; i < 3; i++) {
+    if ((y[i] ?? 0) > (x[i] ?? 0)) return true;
+    if ((y[i] ?? 0) < (x[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+/**
+ * The version the registry currently calls `latest`.
+ *
+ * The registry endpoint rather than `npm view`, because spawning npm to read
+ * one string costs half a second and pulls a whole config resolution in with
+ * it. Resolves `{ version }` or `{ reason }` — never throws, and never blocks
+ * for longer than the timeout.
+ */
+export async function lookupLatestRelease(name = pkgJson().name) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), CHECK_TIMEOUT_MS);
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, {
+      signal: ctrl.signal,
+      headers: { accept: 'application/json', 'user-agent': 'talea' },
+    });
+    if (!res.ok) return { reason: res.status === 404 ? 'unpublished' : 'unreachable' };
+    const { version } = await res.json();
+    return version ? { version } : { reason: 'untagged' };
+  } catch (err) {
+    return { reason: err.name === 'AbortError' ? 'timeout' : 'unreachable', detail: err.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export const latestRelease = async () => (await lookupLatestRelease()).version ?? null;
+
+/** Reinstall globally from the registry. Resolves the exit code. */
+export function installLatest(name = pkgJson().name) {
+  return new Promise((resolve) => {
+    const child = spawn('npm', ['install', '-g', `${name}@latest`], {
+      stdio: 'inherit',
+      // npm is a .cmd on Windows, which spawn cannot exec without a shell.
+      shell: process.platform === 'win32',
+    });
+    child.on('error', () => resolve(1));
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+const checksDisabled = () =>
+  process.env.TALEA_NO_UPDATE_CHECK === '1' || readUserState().updateCheck === false;
+
+/**
+ * Print a one-line notice if a newer version was seen. Uses the *cached* result
+ * so it costs nothing, then refreshes the cache at most once a day.
+ *
+ * Runs after the real work and never throws — an update check must not be able
+ * to fail a clone.
+ */
+export async function notifyIfOutdatedAsync() {
+  if (checksDisabled()) return;
+
+  const { version } = pkgJson();
+  const state = readUserState();
+
+  if (state.latestSeen && isNewer(version, state.latestSeen)) {
+    const { c, glyph } = await import('./log.js');
+    console.log(
+      c.dim(`\n${glyph.rule.repeat(6)}\n`) +
+        `${c.yellow('Update available')} ${c.dim(version)} ${glyph.arrow} ${c.green(state.latestSeen)}  ` +
+        `run ${c.bold('talea upgrade')}\n`,
+    );
+  }
+
+  if (Date.now() - (state.lastCheck ?? 0) <= CHECK_INTERVAL_MS) return;
+
+  const latest = await latestRelease();
+  writeUserState({ ...state, lastCheck: Date.now(), ...(latest ? { latestSeen: latest } : {}) });
+}

package/src/workspace.js

@@ -0,0 +1,116 @@
+// Target selection: turning `--group nonstopio --repo eklavya` into a repo list,
+// and turning "what does this machine want" into one.
+//
+// Every command that acts on repos goes through here, so `clone`, `sync`,
+// `status` and `exec` filter identically.
+
+import { findWorkspace, loadManifest, loadState, repoDir, repoGroup } from './config.js';
+import { isRepo } from './git.js';
+import { fail } from './log.js';
+
+const csv = (v) =>
+  (Array.isArray(v) ? v : [v])
+    .filter(Boolean)
+    .flatMap((s) => String(s).split(','))
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+/**
+ * Resolve the workspace, manifest and state, or exit with a useful message.
+ * Commands that need an initialised workspace call this first.
+ */
+export function requireWorkspace() {
+  const root = findWorkspace();
+  if (!root) {
+    fail('Not inside a talea workspace (no .talea.json found).');
+    console.error('\n  Run `talea init` to create one, or cd into an existing workspace.');
+    process.exit(1);
+  }
+  const manifest = loadManifest(root);
+  const state = loadState(root);
+  return { root, manifest, state };
+}
+
+/**
+ * The repos this machine has signed up for.
+ *
+ * `state.selected` is an explicit list, written by the picker on first sync or
+ * by `talea add`. Until it exists, the catalogue's own `default: true` repos
+ * stand in — that is what "a default set, already ticked" means on a machine
+ * that has never been asked.
+ *
+ * A name in `selected` that the catalogue no longer has is ignored rather than
+ * fatal: repos get renamed and deleted on GitHub, and a machine that has not
+ * run `discover` since should still sync the other twenty.
+ */
+export function machineRepos(manifest, state) {
+  const chosen = state.selected;
+  if (!Array.isArray(chosen)) {
+    return manifest.repos.filter((r) => r.default && !r.archived);
+  }
+  const wanted = new Set(chosen.map((n) => n.toLowerCase()));
+  return manifest.repos.filter((r) => wanted.has(r.name.toLowerCase()));
+}
+
+/** Has this machine ever been asked what it wants? */
+export const hasChosen = (state) => Array.isArray(state.selected);
+
+/**
+ * Filter a repo list by group / repo name.
+ *
+ * Unknown names are a hard error: silently doing nothing because of a typo is
+ * the worst possible outcome for a bulk command.
+ */
+export function selectRepos(manifest, opts = {}, pool = manifest.repos) {
+  const groups = csv(opts.group).map((g) => g.toLowerCase());
+  const names = csv(opts.repo);
+
+  const knownGroups = new Set(manifest.repos.map((r) => repoGroup(r).toLowerCase()));
+  const unknownGroup = groups.find((g) => !knownGroups.has(g));
+  if (unknownGroup) {
+    fail(`Unknown group "${unknownGroup}".`);
+    console.error(`\n  Known groups: ${[...knownGroups].join(', ')}`);
+    process.exit(1);
+  }
+
+  const byName = new Set(manifest.repos.map((r) => r.name.toLowerCase()));
+  const unknownRepo = names.find((n) => !byName.has(n.toLowerCase()));
+  if (unknownRepo) {
+    fail(`Unknown repo "${unknownRepo}".`);
+    console.error('\n  Run `talea list` to see every repo in the catalogue.');
+    process.exit(1);
+  }
+
+  // An explicit -r reaches past the machine's selection on purpose: naming a
+  // repo is a request for that repo, not a request filtered by what was ticked
+  // six months ago.
+  let repos = names.length ? manifest.repos : pool;
+  if (groups.length) repos = repos.filter((r) => groups.includes(repoGroup(r).toLowerCase()));
+  if (names.length) {
+    const wanted = new Set(names.map((n) => n.toLowerCase()));
+    repos = repos.filter((r) => wanted.has(r.name.toLowerCase()));
+  }
+  return repos;
+}
+
+/** Attach the on-disk path and cloned-ness to each repo. */
+export function withPaths(manifest, root, repos) {
+  return repos.map((repo) => {
+    const dir = repoDir(manifest, root, repo);
+    return { repo, dir, cloned: isRepo(dir) };
+  });
+}
+
+/** Only the repos that actually exist on disk — sync/status/exec operate on these. */
+export const clonedOnly = (entries) => entries.filter((e) => e.cloned);
+
+/**
+ * The catalogue is empty, so there is nothing any command can do. Say what to
+ * run rather than printing a successful-looking run over zero repos.
+ */
+export function requireCatalogue(manifest) {
+  if (manifest.repos.length) return;
+  fail('The catalogue is empty.');
+  console.error('\n  Run `talea discover` to build it from your GitHub account.');
+  process.exit(1);
+}