@ajaykumarnpm/talea 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,11 @@ 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.5.0] - 2026-09-22
+
+### Added
+- run commands from outside a workspace
+
 ## [0.4.0] - 2026-09-22
 
 ### Added

package/README.md

@@ -46,6 +46,9 @@ talea manifest push          # publish the catalogue so the next machine can rea
 repos, every org you belong to, and anything shared with you directly. It then
 asks what this machine should keep and fills the tree.
 
+Every command works from anywhere after that. Outside the workspace it uses
+the one `init` made; with more than one on the machine, it asks which.
+
 ## Every machine after that
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ajaykumarnpm/talea",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "One folder structure for every machine. Clone, adopt and sync your GitHub repos from a manifest you own.",
   "type": "module",
   "bin": {

package/skills/talea/SKILL.md

@@ -46,6 +46,10 @@ It exits **non-zero** on an unknown name and writes every diagnostic to stderr,
 so `cd "$(talea where typo)"` fails instead of landing in the home directory.
 Never `cd` to a path it did not print.
 
+Outside a workspace it falls back to the ones this machine has. With several
+and no terminal — which is how you run it — it lists them and exits non-zero.
+`cd` into the workspace the user means rather than guessing from the list.
+
 Two owners can own a repo of the same name. When that happens it says so and
 exits non-zero — pass `owner/name` rather than picking one.
 

package/src/commands/add.js

@@ -54,7 +54,7 @@ export function resolve(manifest, name) {
 }
 
 export async function run(opts, positionals = []) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   requireCatalogue(manifest);
 
   if (!positionals.length) {

package/src/commands/adopt.js

@@ -322,7 +322,7 @@ export function parseFromPaths(from) {
 }
 
 export async function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
 
   if (opts['fix-paths']) {
     heading('Repairing paths for repos already adopted');

package/src/commands/clone.js

@@ -200,7 +200,7 @@ export function writeDocs(manifest, root, repos) {
 }
 
 export async function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   requireCatalogue(manifest);
 
   const protocol = opts.protocol ?? state.protocol ?? 'ssh';

package/src/commands/exec.js

@@ -46,7 +46,7 @@ export async function run(opts, positionals) {
     process.exit(1);
   }
 
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   const pool = opts.all ? manifest.repos : machineRepos(manifest, state);
   const entries = clonedOnly(withPaths(manifest, root, selectRepos(manifest, opts, pool)));
 

package/src/commands/init.js

@@ -15,6 +15,7 @@ import { samePath } from '../adopt.js';
 import { c, context, fail, heading, info, ok, plain, skip, warn } from '../log.js';
 import { run as discover } from './discover.js';
 import { run as sync } from './sync.js';
+import { rememberWorkspace } from '../workspace.js';
 
 export const help = `
 ${c.bold('talea init')} — set this machine up
@@ -105,6 +106,8 @@ export async function run(opts, positionals = []) {
   } else {
     skip(`${STATE_FILE} already here, leaving it alone`);
   }
+  // So `talea sync` run from outside any workspace knows this one exists.
+  rememberWorkspace(target);
 
   let manifest = loadManifest(target);
 

package/src/commands/select.js

@@ -48,7 +48,7 @@ export function changes(before, after) {
 }
 
 export async function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   requireCatalogue(manifest);
 
   // -g/-r narrow a run; they cannot narrow a decision about the whole machine.

package/src/commands/status.js

@@ -29,7 +29,7 @@ Options
 `;
 
 export async function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   const pool = opts.all ? manifest.repos : machineRepos(manifest, state);
   const entries = withPaths(manifest, root, selectRepos(manifest, opts, pool));
 

package/src/commands/sync.js

@@ -31,6 +31,9 @@ your default set, or a checklist of everything in the catalogue with those
 defaults already ticked. The answer is remembered in ${c.dim('.talea.json')}, so every run
 after that is a bare ${c.dim('talea sync')}.
 
+It runs from anywhere. Inside a workspace it uses that one; outside, it uses
+the workspace ${c.dim('talea init')} made, or asks which when this machine has several.
+
 Options
   -g, --group <names>   comma-separated groups
   -r, --repo <names>    comma-separated repo names
@@ -53,7 +56,7 @@ leaves it alone, and says which.
 `;
 
 export async function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+  const { root, manifest, state } = await requireWorkspace();
   requireCatalogue(manifest);
 
   const protocol = opts.protocol ?? state.protocol ?? 'ssh';

package/src/commands/tree.js

@@ -30,8 +30,8 @@ Options
 
 const hasDoc = (dir) => existsSync(path.join(dir, 'CLAUDE.md'));
 
-export function run(opts) {
-  const { root, manifest, state } = requireWorkspace();
+export async function run(opts) {
+  const { root, manifest, state } = await requireWorkspace();
   const pool = opts.all ? manifest.repos : machineRepos(manifest, state);
   const entries = withPaths(manifest, root, selectRepos(manifest, opts, pool));
 

package/src/commands/where.js

@@ -17,10 +17,13 @@ composes with ${c.dim('cd')}, ${c.dim('code')}, ${c.dim('open')} and anything el
 
 Exits non-zero if the repo is not in the catalogue, so ${c.dim('cd $(talea where typo)')}
 fails loudly instead of landing you in your home directory.
+
+Works from outside a workspace too: with one on this machine it uses that, with
+several it asks — on stderr, so the answer never ends up in the path.
 `;
 
-export function run(opts, positionals = []) {
-  const { root, manifest } = requireWorkspace();
+export async function run(opts, positionals = []) {
+  const { root, manifest } = await requireWorkspace();
   const name = positionals[0];
 
   if (!name) {

package/src/config.js

@@ -33,7 +33,7 @@ export const USER_STATE = path.join(USER_DIR, 'state.json');
 
 const readJson = (file) => JSON.parse(readFileSync(file, 'utf8'));
 
-/** Machine-wide state: the update-check stamp, the gist id. Not per workspace. */
+/** Machine-wide state: the update-check stamp, the gist id, the workspace list. Not per workspace. */
 export function readUserState() {
   try {
     return readJson(USER_STATE);
@@ -48,7 +48,8 @@ export function writeUserState(state) {
     writeFileSync(USER_STATE, JSON.stringify(state, null, 2) + '\n');
   } catch {
     // A read-only home directory must not break the actual command. The only
-    // things kept here are a cache stamp and a gist id.
+    // things kept here are a cache stamp, a gist id and the workspace list,
+    // and a lost list re-fills itself the next time a command runs inside one.
   }
 }
 
@@ -95,6 +96,19 @@ export function findWorkspace(start = process.cwd()) {
   }
 }
 
+/**
+ * Every workspace this machine has set up, as recorded in ~/.talea/state.json.
+ *
+ * This is what lets `talea sync` run from anywhere: outside a workspace the
+ * upward walk finds nothing, and this list is what is left to ask. Kept in the
+ * machine-wide state rather than the catalogue because a path on this laptop
+ * means nothing on the next one. Entries whose .talea.json has gone are skipped
+ * on read, not dropped on write — a deleted workspace stops being offered, but
+ * an unplugged drive that comes back has not been forgotten.
+ */
+export const knownWorkspaces = () =>
+  (readUserState().workspaces ?? []).filter((dir) => existsSync(path.join(dir, STATE_FILE)));
+
 export function loadState(workspaceRoot) {
   const file = path.join(workspaceRoot, STATE_FILE);
   return existsSync(file) ? readJson(file) : {};

package/src/workspace.js

@@ -4,9 +4,25 @@
 // 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 { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+
+import { samePath } from './adopt.js';
+import {
+  STATE_FILE,
+  findWorkspace,
+  knownWorkspaces,
+  loadManifest,
+  loadState,
+  readUserState,
+  repoDir,
+  repoGroup,
+  writeUserState,
+} from './config.js';
 import { isRepo } from './git.js';
-import { fail } from './log.js';
+import { c, fail } from './log.js';
 
 const csv = (v) =>
   (Array.isArray(v) ? v : [v])
@@ -16,16 +32,87 @@ const csv = (v) =>
     .filter(Boolean);
 
 /**
- * Resolve the workspace, manifest and state, or exit with a useful message.
- * Commands that need an initialised workspace call this first.
+ * Add a workspace to this machine's list, once.
+ *
+ * Compared with samePath, not as strings: on macOS and Windows `~/workspace`
+ * and `~/Workspace` are one folder, and cd-ing in with the other spelling would
+ * otherwise add it again on every run.
+ */
+export function rememberWorkspace(root) {
+  const state = readUserState();
+  const list = state.workspaces ?? [];
+  if (list.some((dir) => samePath(dir, root))) return;
+  writeUserState({ ...state, workspaces: [...list, root] });
+}
+
+/**
+ * The workspaces a command run from outside any of them could mean: every one
+ * `init` has recorded, plus the default `~/Workspace` — which is how a
+ * workspace made before the list existed is still found from anywhere.
  */
-export function requireWorkspace() {
-  const root = findWorkspace();
-  if (!root) {
+export function workspaceCandidates(known = knownWorkspaces(), manifest = loadManifest(null)) {
+  const fallback = path.join(os.homedir(), manifest.workspace || 'Workspace');
+  const all = existsSync(path.join(fallback, STATE_FILE)) ? [...known, fallback] : known;
+  return all.filter((dir, i) => all.findIndex((d) => samePath(d, dir)) === i);
+}
+
+/**
+ * Outside a workspace: one known workspace is used, several are asked about.
+ *
+ * Everything here goes to stderr — `cd $(talea where)` reads stdout, and a
+ * prompt or a note there is a folder the shell tries to enter. With no
+ * terminal to ask on, it stops rather than picks: a script that syncs whichever
+ * workspace happened to be first is running against a tree nobody named.
+ */
+async function pickKnownWorkspace() {
+  const found = workspaceCandidates();
+
+  if (!found.length) {
     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);
   }
+  if (found.length === 1) {
+    console.error(c.dim(`Using the workspace at ${found[0]}\n`));
+    return found[0];
+  }
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    fail(`Not inside a talea workspace, and this machine has ${found.length}.`);
+    for (const dir of found) console.error(`    ${c.bold(dir)}`);
+    console.error('\n  cd into the one you mean.');
+    process.exit(1);
+  }
+
+  console.error(`\n${c.bold('Which workspace?')}`);
+  found.forEach((dir, i) => console.error(`  ${c.cyan(String(i + 1))}  ${dir}`));
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = (await rl.question(`\n${c.dim(`[1-${found.length}]`)} `)).trim();
+  rl.close();
+
+  // A wrong answer stops, same as a typo'd repo name: guessing here would run
+  // a bulk command against a tree the developer did not choose.
+  const chosen = found[Number(answer) - 1];
+  if (!/^\d+$/.test(answer) || !chosen) {
+    fail(`"${answer}" is not one of 1-${found.length}.`);
+    process.exit(1);
+  }
+  console.error('');
+  return chosen;
+}
+
+/**
+ * Resolve the workspace, manifest and state, or exit with a useful message.
+ * Commands that need an initialised workspace call this first.
+ *
+ * Inside a workspace the upward walk wins, exactly as git's does. Outside one,
+ * the workspaces this machine knows about are offered instead.
+ */
+export async function requireWorkspace() {
+  const inside = findWorkspace();
+  // Recorded on every run from inside, so a workspace made before the list
+  // existed joins it the first time anything is run there.
+  if (inside) rememberWorkspace(inside);
+  const root = inside ?? (await pickKnownWorkspace());
   const manifest = loadManifest(root);
   const state = loadState(root);
   return { root, manifest, state };