@ajaykumarnpm/talea 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to this project are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the versions follow
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] - 2026-09-21
+
+### Added
+- talea select reopens the checklist
+
+### Chores
+- ignore .idea/
+
+## [0.2.2] - 2026-09-21
+
+### Documentation
+- the skip marker is read from the commit body too
+
+### Chores
+- publish before pushing the tag
+- the pipeline cuts the release, not a laptop
+
+## [0.2.1] - 2026-09-21
+
+### Fixed
+- The live block no longer repeats itself down the screen. A row wider than the
+  terminal wrapped onto a second line, which threw off the cursor arithmetic the
+  block redraws with, so every frame landed a line lower than the last. Rows are
+  now cut to the window width.
+
+### Chores
+- Releases are published by a GitHub release rather than by pushing a tag, and
+  npm authenticates with trusted publishing instead of a stored token.
+
+## [0.2.0] - 2026-09-21
+
+### Added
+- `ignore: true` in the catalogue marks a checkout that another tool owns. No
+  command touches it — not `sync`, not `adopt`, not an explicit selection.
+
+### Fixed
+- `init` defaults to `~/Workspace` and refuses to turn your home directory into
+  a workspace.
+- `adopt` moves a repo's worktrees with it and repairs their links, instead of
+  leaving them stranded.
+- A repo that matches only by name is never moved unattended. Say `--loose`, or
+  name it with `-r`, to move one anyway.
+
+## [0.1.0] - 2026-09-21
+
+### Added
+- First published release: `discover`, `clone`, `sync`, `adopt`, `add`, `rm`,
+  `where`, `status` and `doctor`, the live progress block, and the shared
+  catalogue with a per-machine selection that never travels with it.
+- Published as `@ajaykumarnpm/talea` — npm's typo-squatting filter refused the
+  bare name.

package/README.md

@@ -60,6 +60,7 @@ this machine needs, untick what it does not, press enter.
 talea sync                   # clone the new, fast-forward the rest
 talea status                 # branch, clean/dirty, ahead/behind, in one table
 talea add some-repo          # keep one more on this machine, and clone it now
+talea select                 # reopen the checklist and change the whole list
 cd $(talea where eklavya)
 ```
 
@@ -146,7 +147,8 @@ Treat the id like a bookmark you would not paste into a public channel.
 | `talea clone` | clone only — never fetches or merges |
 | `talea adopt` | move checkouts you already have into place |
 | `talea status` | branch, clean/dirty, ahead/behind |
-| `talea add` / `talea rm` | change what this machine keeps |
+| `talea select` | reopen the checklist — what this machine keeps |
+| `talea add` / `talea rm` | change that one repo at a time |
 | `talea where <repo>` | print a repo's path, for `cd $( )` |
 | `talea list` | the catalogue |
 | `talea tree` | the folder tree on disk |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ajaykumarnpm/talea",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "One folder structure for every machine. Clone, adopt and sync your GitHub repos from a manifest you own.",
   "type": "module",
   "bin": {
@@ -17,7 +17,8 @@
     "src",
     "manifest",
     "templates",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "test": "node --test"

package/src/cli.js

@@ -8,6 +8,7 @@ import { c, fail, plain } from './log.js';
 import * as init from './commands/init.js';
 import * as discover from './commands/discover.js';
 import * as clone from './commands/clone.js';
+import * as select from './commands/select.js';
 import * as adopt from './commands/adopt.js';
 import * as sync from './commands/sync.js';
 import * as status from './commands/status.js';
@@ -28,6 +29,7 @@ const COMMANDS = {
   init,
   discover,
   clone,
+  select,
   adopt,
   sync,
   status,
@@ -50,6 +52,8 @@ const ALIASES = {
   pull: 'sync',
   update: 'sync',
   refresh: 'discover',
+  pick: 'select',
+  choose: 'select',
   ls: 'list',
   st: 'status',
   cd: 'where',
@@ -103,6 +107,7 @@ ${c.bold('Commands')}
   ${c.cyan('clone')}      clone only — never fetches or merges
   ${c.cyan('adopt')}      move repos you already have into the right place
   ${c.cyan('status')}     one table: branch, clean/dirty, ahead/behind
+  ${c.cyan('select')}     reopen the checklist — what this machine keeps
   ${c.cyan('add')}        keep another repo on this machine (${c.dim('rm')} to drop one)
   ${c.cyan('where')}      print a repo's path — ${c.dim('cd $(talea where eklavya)')}
   ${c.cyan('list')}       show the catalogue

package/src/commands/select.js

@@ -0,0 +1,79 @@
+// `talea select` — reopen the checklist and change what this machine keeps.
+//
+// `add` and `rm` are the one-repo door. This is the door for "let me look at
+// the whole list again", which until now was reachable only as `--pick` on a
+// command you had to already know to run. The picker was the first thing `init`
+// showed and then had no name of its own.
+//
+// It is deliberately thin: the picking and the saving live in `src/select.js`
+// because `clone` and `sync` ask the same question, and the cloning is
+// `clone.run`, re-entered after the new selection is on disk.
+
+import { c, fail, heading, ok, plain, skip } from '../log.js';
+import { chooseRepos } from '../select.js';
+import { machineRepos, requireCatalogue, requireWorkspace } from '../workspace.js';
+import * as clone from './clone.js';
+
+export const help = `
+${c.bold('talea select')} — change what this machine keeps
+
+  ${c.dim('talea select')}              reopen the checklist, then clone what is newly ticked
+  ${c.dim('talea select --no-clone')}   change the list only, fill it in later
+
+The checklist opens with the current selection ticked. Space toggles, Enter
+saves, Esc cancels and changes nothing. Everything in the catalogue is listed,
+including the archived and the forks — this machine is allowed to keep
+something the default set does not have.
+
+It writes ${c.dim('.talea.json')}, which never leaves this machine, so no other machine's
+selection changes. Unticking a repo takes it off the list and leaves the
+checkout exactly where it is; deleting it is your call.
+
+For one repo, ${c.dim('talea add <repo>')} and ${c.dim('talea rm <repo>')} skip the checklist.
+
+Options
+      --no-clone        save the selection, clone nothing
+      --protocol <p>    ssh (default) or https
+  -j, --jobs <n>        parallel clones
+`;
+
+/** What changed, as two lists of names. Pure, so it can be tested. */
+export function changes(before, after) {
+  const had = new Set(before);
+  const has = new Set(after);
+  return {
+    added: after.filter((n) => !had.has(n)),
+    dropped: before.filter((n) => !has.has(n)),
+  };
+}
+
+export async function run(opts) {
+  const { root, manifest, state } = requireWorkspace();
+  requireCatalogue(manifest);
+
+  // -g/-r narrow a run; they cannot narrow a decision about the whole machine.
+  // Accepting them silently would return the old selection unchanged and look
+  // like the picker had simply declined to open.
+  if (opts.group || opts.repo) {
+    fail('`select` is about the whole list — -g/-r do not narrow it.');
+    console.error('\n  Use `talea add <repo>` or `talea rm <repo>` for one repo at a time.');
+    process.exit(1);
+  }
+
+  const before = machineRepos(manifest, state).map((r) => r.name);
+  const { repos } = await chooseRepos({ manifest, root, state, opts: { ...opts, pick: true } });
+  const after = repos.map((r) => r.name);
+  const { added, dropped } = changes(before, after);
+
+  heading('This machine keeps');
+  for (const name of added) ok(`${c.bold(name)} ${c.dim('added')}`);
+  for (const name of dropped) {
+    skip(`${c.bold(name)} ${c.dim('off the list — the checkout stays where it is')}`);
+  }
+  plain(c.dim(`    ${after.length} repos`));
+
+  if (!added.length || opts.clone === false) return;
+
+  // The selection is on disk now, so clone reads it back and never re-asks.
+  await clone.run({ ...opts, pick: false });
+}

package/src/live.js

@@ -19,6 +19,7 @@ import {
   paint,
   spinner,
   statusLine,
+  truncVisible,
   visibleWidth,
 } from './log.js';
 
@@ -95,10 +96,18 @@ export function board(items, { live = process.stdout.isTTY } = {}) {
     drawn = 0;
   };
 
+  // One line, one row. A line wider than the window wraps, and then `drawn` —
+  // a count of lines, not of rows — climbs back too few rows and the next frame
+  // is drawn below the last one instead of over it. That is how the block ends
+  // up repeating itself down the screen with half-cleared remnants in between.
+  // The last column is left empty: a line filling the row exactly leaves some
+  // terminals in a deferred-wrap state that the following newline then spends.
+  const fitRow = (l) => truncVisible(l, Math.max(1, (process.stdout.columns || 80) - 1));
+
   const draw = () => {
     const body = lines();
     let s = (drawn ? ansi.up(drawn) : '') + ansi.cr;
-    for (const l of body) s += ansi.clearLine + l + '\n';
+    for (const l of body) s += ansi.clearLine + fitRow(l) + '\n';
     // The previous block may have been taller — clear what is left of it, then
     // put the cursor back under the new one.
     const extra = Math.max(0, drawn - body.length);

package/src/log.js

@@ -17,11 +17,12 @@ import {
   padEndVisible,
   spinner,
   stripAnsi,
+  truncVisible,
   useColor,
   visibleWidth,
 } from './theme.js';
 
-export { ansi, glyph, padEndVisible, paint, spinner, useColor, visibleWidth };
+export { ansi, glyph, padEndVisible, paint, spinner, truncVisible, useColor, visibleWidth };
 
 /**
  * Named colours, kept because every command's `help` string and most inline

package/src/theme.js

@@ -136,3 +136,37 @@ export function centerVisible(s, width) {
 
 /** Terminal width, clamped to something a human can read across. */
 export const columns = () => Math.max(40, Math.min(process.stdout.columns || 80, 120));
+
+/**
+ * Cut a string to `width` visible columns, leaving its escape codes intact.
+ *
+ * The live block redraws by counting the lines it wrote and climbing back up
+ * that many. A line wider than the window wraps onto two rows, so the count is
+ * short by one and every redraw lands a row lower — the block duplicates itself
+ * down the screen. Truncating keeps one line to one row.
+ */
+export function truncVisible(s, width) {
+  const str = String(s);
+  if (width <= 0) return '';
+  if (visibleWidth(str) <= width) return str;
+  let left = width;
+  let out = '';
+  // eslint-disable-next-line no-control-regex
+  for (const part of str.split(/(\x1b\[[0-9;?]*[A-Za-z])/)) {
+    if (!part) continue;
+    if (part.startsWith('\x1b[')) {
+      out += part;
+      continue;
+    }
+    const chars = [...part];
+    if (chars.length <= left) {
+      out += part;
+      left -= chars.length;
+    } else {
+      out += chars.slice(0, left).join('');
+      left = 0;
+    }
+  }
+  // Cut mid-colour, so close it — otherwise the colour bleeds down the screen.
+  return out + (useColor ? '\x1b[0m' : '');
+}