git-sich 0.2.0 → 0.3.0

package/README.md

@@ -94,6 +94,7 @@ setup
   new <layer> [--remote <url> | --gh [name]]
                                     create a layer (--gh: private GitHub repo)
   attach <layer> <url>              join an existing layer (collaborators)
+  detach <layer> [--force] [--yes]  remove a layer here; files and remote stay
 
 ownership
   claim <layer> <path...> [--move]  claim files/folders for a layer, stage them

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { realpathSync as realpathSync3, statSync } from "node:fs";
 import { resolve as resolve6 } from "node:path";
 // package.json
-var version = "0.2.0";
+var version = "0.3.0";
 
 // src/ui.ts
 class SichError extends Error {
@@ -42,6 +42,23 @@ function printError(message) {
   process.stderr.write(`${ce.red("sich:")} ${message}
 `);
 }
+async function confirm(question) {
+  process.stderr.write(`${question} [y/N] `);
+  let answer = "";
+  try {
+    for await (const chunk of process.stdin) {
+      answer += String(chunk);
+      if (answer.includes(`
+`))
+        break;
+    }
+  } catch {}
+  if (!process.stdin.isTTY)
+    process.stderr.write(`
+`);
+  return /^y(es)?$/i.test(answer.split(`
+`)[0].trim());
+}
 function plural(n, word, pluralWord = word + "s") {
   return `${n} ${n === 1 ? word : pluralWord}`;
 }
@@ -405,6 +422,7 @@ var COMMANDS = [
   "init",
   "new",
   "attach",
+  "detach",
   "claim",
   "unclaim",
   "add",
@@ -1164,7 +1182,7 @@ function cmdLs(ctx, args) {
 
 // src/commands/layer.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync6, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync6, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename as basename3, isAbsolute as isAbsolute2, join as join4, resolve as resolve5 } from "node:path";
 function assertFree(ctx, layer) {
   validateLayerName(layer);
@@ -1290,6 +1308,166 @@ function cmdAttach(ctx, args) {
   installLayerHooks(ctx, layer);
   return 0;
 }
+var IN_PROGRESS = [
+  ["MERGE_HEAD", "merge"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply/applying", "am"],
+  ["rebase-apply", "rebase"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"]
+];
+var preferredRemote = (remotes) => remotes.includes("origin") ? "origin" : remotes[0];
+function onlyInGitDir(repo) {
+  const run = `sich ${repo.name}`;
+  const losses = [];
+  const count = (revs, allowFail = false) => Number(git(repo, ["rev-list", "--count", ...revs, "--"], { allowFail }).stdout.trim() || 0);
+  const remote = preferredRemote(remotesOf(repo));
+  if (!remote) {
+    const n = count(["--exclude=refs/stash", "--all"]);
+    losses.push({
+      what: `${plural(n, "commit")} with no remote to push to`,
+      fix: `${run} remote add origin <url>, then sich push ${repo.name}`
+    });
+  } else {
+    const current = currentBranch(repo);
+    const refs = lines(git(repo, ["for-each-ref", "--format=%(objectname) %(refname)"]).stdout).map((l) => {
+      const [oid, ref] = l.split(" ");
+      return { oid, ref };
+    });
+    for (const { ref } of refs.filter((r) => r.ref.startsWith("refs/heads/"))) {
+      const n = count([ref, "--not", "--remotes"]);
+      if (!n)
+        continue;
+      const branch = ref.slice("refs/heads/".length);
+      losses.push({
+        what: `${plural(n, "commit")} on ${branch} not on any remote`,
+        fix: branch === current ? `sich push ${repo.name}` : `${run} push -u ${remote} ${shellQuote(branch)}`
+      });
+    }
+    let advertised;
+    const remoteHas = (oid) => {
+      if (advertised === undefined) {
+        const r = git(repo, ["ls-remote", remote], { allowFail: true });
+        advertised = r.code === 0 ? new Set(lines(r.stdout).map((l) => l.split("\t")[0])) : null;
+      }
+      return advertised?.has(oid) ?? false;
+    };
+    const others = refs.filter((r) => !/^refs\/(heads|remotes|prefetch)\//.test(r.ref) && r.ref !== "refs/stash");
+    for (const { oid, ref } of others) {
+      const n = count([`${ref}^{commit}`, "--not", "--remotes", "--branches"], true);
+      if (!n || remoteHas(oid))
+        continue;
+      const name = ref.startsWith("refs/tags/") ? ref.slice("refs/tags/".length) : ref;
+      const unchecked = advertised === null ? ` (could not reach ${remote} to check)` : "";
+      losses.push({
+        what: `${plural(n, "commit")} only on ${name === ref ? ref : `tag ${name}`}${unchecked}`,
+        fix: `${run} push ${remote} ${shellQuote(name)}`
+      });
+    }
+    if (current === null) {
+      const n = count(["HEAD", "--not", "--remotes", "--branches", "--tags"]);
+      if (n) {
+        losses.push({ what: `${plural(n, "commit")} only on the detached HEAD`, fix: `${run} switch -c <branch>` });
+      }
+    }
+  }
+  const stashes = lines(git(repo, ["stash", "list"]).stdout).length;
+  if (stashes) {
+    losses.push({ what: plural(stashes, "stash entry", "stash entries"), fix: `${run} stash pop, then commit` });
+  }
+  const staged = splitZ(git(repo, ["diff", "--cached", "--name-only", "-z", "--no-renames", "--diff-filter=du"]).stdout);
+  const changed = new Set(splitZ(git(repo, ["diff", "--name-only", "-z", "--no-renames"]).stdout));
+  for (const e of splitZ(git(repo, ["ls-files", "-v", "-z"]).stdout)) {
+    if (/^[a-zS] /.test(e))
+      changed.add(e.slice(2));
+  }
+  const stagedOnly = staged.filter((f) => changed.has(f));
+  if (stagedOnly.length) {
+    losses.push({
+      what: `staged versions of ${listSome(stagedOnly)} that differ from what is on disk`,
+      fix: `${run} commit -m <msg>, then sich push ${repo.name}`
+    });
+  }
+  const worktrees = lines(git(repo, ["worktree", "list", "--porcelain"]).stdout).filter((l) => l.startsWith("worktree ")).slice(1).map((l) => l.slice("worktree ".length));
+  if (worktrees.length) {
+    losses.push({
+      what: `${plural(worktrees.length, "linked worktree")}: ${listSome(worktrees)}`,
+      fix: `${run} worktree remove <path>`
+    });
+  }
+  const modules = join4(repo.gitDir, "modules");
+  if (existsSync6(modules) && readdirSync2(modules).length) {
+    losses.push({ what: `submodule repos in .sich/${repo.name}/modules/`, fix: `push and remove the submodules` });
+  }
+  const op = IN_PROGRESS.find(([file]) => existsSync6(join4(repo.gitDir, file)))?.[1];
+  if (op)
+    losses.push({ what: `a ${op} in progress`, fix: `finish it, or ${run} ${op} --abort` });
+  return losses;
+}
+async function cmdDetach(ctx, args) {
+  const p = parseArgs(args, { "--force": "bool", "--yes": "bool" }, { "-y": "--yes" });
+  const [layer, ...extra] = p.positionals;
+  if (!layer || extra.length)
+    fail("usage: sich detach <layer> [--force] [--yes]");
+  const repo = requireLayer(ctx, layer);
+  const losses = onlyInGitDir(repo);
+  if (losses.length && !p.flags["--force"]) {
+    for (const l of losses)
+      out(`${c.red("✗")} ${l.what} (fix: ${l.fix})`);
+    fail(`detaching ${layer} would lose what exists only in .sich/${layer}/ (see above); --force discards it`);
+  }
+  const claims = readManifest(manifestPath(ctx, layer), layer).claims;
+  const remote = preferredRemote(remotesOf(repo));
+  const url = remote && git(repo, ["remote", "get-url", remote], { allowFail: true }).stdout.trim();
+  if (p.flags["--yes"]) {
+    for (const l of losses)
+      warn(`discarding ${l.what}`);
+  } else {
+    const onDisk = claims.filter((cl) => existsSync6(join4(ctx.root, bare(cl))));
+    const row = (label, text) => out(`  ${label}${" ".repeat(10 - label.length)}${text}`);
+    out(`detaching ${c.bold(layer)}:`);
+    row("deletes", `.sich/${layer}/ (its git data: local history, index, hooks, config)`);
+    if (existsSync6(manifestPath(ctx, layer))) {
+      row("deletes", `${manifestRel(layer)} (claims list: ${claims.length ? listSome(claims) : "empty"})`);
+    }
+    for (const l of losses)
+      row("discards", l.what);
+    row("keeps", onDisk.length ? `${listSome(onDisk)} on disk, no longer hidden from base` : "files: none on disk");
+    if (url)
+      row("keeps", `remote ${remote} (${url}) and everything pushed to it`);
+    if (!await confirm(`Detach ${layer}?`)) {
+      fail(process.stdin.isTTY ? "not detached" : "not detached (no answer on stdin; --yes skips the question)");
+    }
+    const shown = new Set(losses.map((l) => l.what));
+    const added = onlyInGitDir(repo).filter((l) => !shown.has(l.what));
+    if (added.length) {
+      for (const l of added)
+        out(`${c.red("✗")} ${l.what} (fix: ${l.fix})`);
+      fail(`${layer} changed while waiting for the answer (see above); not detached`);
+    }
+  }
+  const manifest = existsSync6(manifestPath(ctx, layer));
+  rmSync(repo.gitDir, { recursive: true, force: true });
+  rmSync(manifestPath(ctx, layer), { force: true });
+  const deleted = `git data -> .sich/${layer}/${manifest ? `, claims list -> ${manifestRel(layer)}` : ""}`;
+  out(`${c.green("detached")} layer ${c.bold(layer)}: deleted ${deleted}`);
+  for (const t of excludeTargets(ctx)) {
+    if (!applyExclude(t, true))
+      continue;
+    const file = excludeFileShown(t.repo);
+    out(t.repo.name === "base" ? `no longer hidden from base -> ${file}` : `updated the excludes of ${t.repo.name} -> ${file}`);
+  }
+  const untracked = ["ls-files", "-z", "--others", "--exclude-standard", "--directory", "--no-empty-directory"];
+  const visible = claims.length ? splitZ(git(ctx.base, [...untracked, "--", ...claims]).stdout) : [];
+  if (visible.length) {
+    warn(`base now sees ${listSome(visible)} as untracked ` + `(delete, .gitignore or claim ${visible.length === 1 ? "it" : "them"} before committing base)`);
+  }
+  if (url) {
+    const away = claims.some((cl) => existsSync6(join4(ctx.root, bare(cl)))) ? "move its files away, then " : "";
+    note(`its remote is untouched; to attach again: ${away}sich attach ${layer} ${shellQuote(url)}`);
+  }
+  return 0;
+}
 
 // src/commands/status.ts
 function parseStatus(raw) {
@@ -1525,6 +1703,7 @@ setup
   new <layer> [--remote <url> | --gh [name]]
                                     create a layer (--gh: private GitHub repo)
   attach <layer> <url>              join an existing layer (collaborators)
+  detach <layer> [--force] [--yes]  remove a layer here; files and remote stay
 
 ownership
   claim <layer> <path...> [--move]  claim files/folders for a layer, stage them
@@ -1587,6 +1766,21 @@ its pre-commit and pre-merge-commit hooks (see sich init).
 Joins an existing layer: fetches <url> and checks out its default branch into
 this working tree, and installs its pre-commit and pre-merge-commit hooks (see
 sich init). Refuses to overwrite existing files.`,
+  detach: `usage: sich detach <layer> [--force] [--yes]
+
+The opposite of attach: removes a layer from this working tree by deleting its
+git data (.sich/<layer>/) and claims list (.sich/<layer>.paths). Its files stay
+on disk, no longer hidden from base (nothing stops base from committing them
+any more), and its remote is left alone: attach it again any time.
+Refuses if that would lose what exists only in .sich/<layer>/: commits on no
+remote (for branches: as of the last fetch or push), stashes, staged versions
+of files that changed again on disk, linked worktrees, submodule repos, or a
+merge, rebase or similar in progress. Uncommitted changes to files don't
+count, since the files stay.
+Lists what it deletes and what it keeps, then asks before doing it (no answer,
+e.g. without a terminal, means no).
+  --force     detach anyway, discarding all of that
+  -y, --yes   don't ask`,
   claim: `usage: sich claim <layer> <path...> [--move]
 
 Claims paths (files or directories, relative to the current directory) for a
@@ -1669,6 +1863,7 @@ var HANDLERS = {
   init: cmdInit,
   new: cmdNew,
   attach: cmdAttach,
+  detach: cmdDetach,
   claim: cmdClaim,
   unclaim: cmdUnclaim,
   add: cmdClaim,
@@ -1695,7 +1890,7 @@ function changeDir(cwd, dir) {
     fail(`-C ${dir}: no such directory`);
   }
 }
-function main(argv) {
+async function main(argv) {
   let cwd = realpathSync3.native(process.cwd());
   let i = 0;
   for (;i < argv.length; i++) {
@@ -1754,7 +1949,7 @@ function main(argv) {
 }
 var code;
 try {
-  code = main(process.argv.slice(2));
+  code = await main(process.argv.slice(2));
 } catch (e) {
   if (e instanceof SichError)
     printError(e.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-sich",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Private git layers sharing one working tree with a normal (public) repo",
   "keywords": [
     "git",