get-tbd 0.1.24 → 0.1.25

package/README.md

@@ -279,7 +279,7 @@ npm install -g get-tbd@latest
 ### Setup
 
 ```bash
-# Fresh project (--prefix is REQUIRED—2-8 alphabetic chars, e.g. myapp-a1b2)
+# Fresh project (--prefix is REQUIRED—a short alphabetic name used as an issue ID prefix, e.g. myapp → issues like myapp-a1b2)
 tbd setup --auto --prefix=myapp
 
 # Joining an existing tbd project (no prefix needed—reads existing config)
@@ -299,7 +299,7 @@ tbd setup --from-beads
 **First contributor:**
 ```bash
 npm install -g get-tbd@latest
-tbd setup --auto --prefix=myproject
+tbd setup --auto --prefix=proj   # Short alphabetic prefix for issue IDs
 git add .tbd/ .claude/ && git commit -m "Initialize tbd"
 git push
 ```

package/dist/bin.mjs

@@ -14033,7 +14033,7 @@ function serializeIssue(issue) {
 * Package version, derived from git at build time.
 * Format: X.Y.Z for releases, X.Y.Z-dev.N.hash for dev builds.
 */
-const VERSION$1 = "0.1.24";
+const VERSION$1 = "0.1.25";
 
 //#endregion
 //#region src/cli/lib/version.ts
@@ -99751,28 +99751,32 @@ async function listIssues(baseDir) {
 		return [];
 	}
 	const mdFiles = files.filter((f) => f.endsWith(".md"));
-	const fileContents = await Promise.all(mdFiles.map(async (file) => {
-		const filePath = join(issuesDir, file);
-		try {
-			return {
-				file,
-				content: await readFile(filePath, "utf-8")
-			};
-		} catch {
-			return {
-				file,
-				content: null
-			};
-		}
-	}));
+	const BATCH_SIZE = 200;
 	const issues = [];
-	for (const { file, content } of fileContents) {
-		if (content === null) continue;
-		try {
-			const issue = parseIssue(content);
-			issues.push(issue);
-		} catch (error) {
-			console.warn(`Skipping invalid issue file: ${file}`, error);
+	for (let i = 0; i < mdFiles.length; i += BATCH_SIZE) {
+		const batch = mdFiles.slice(i, i + BATCH_SIZE);
+		const fileContents = await Promise.all(batch.map(async (file) => {
+			const filePath = join(issuesDir, file);
+			try {
+				return {
+					file,
+					content: await readFile(filePath, "utf-8")
+				};
+			} catch {
+				return {
+					file,
+					content: null
+				};
+			}
+		}));
+		for (const { file, content } of fileContents) {
+			if (content === null) continue;
+			try {
+				const issue = parseIssue(content);
+				issues.push(issue);
+			} catch (error) {
+				console.warn(`Skipping invalid issue file: ${file}`, error);
+			}
 		}
 	}
 	return issues;
@@ -99814,30 +99818,44 @@ async function listIssues(baseDir) {
 *    crashed and break the lock. This is a heuristic — safe when the critical
 *    section is short-lived (sub-second for file I/O).
 *
-* ## Degraded mode
+* ## Failure on timeout
+*
+* If the lock cannot be acquired within the timeout, a LockAcquisitionError is
+* thrown. This prevents the dangerous "degraded mode" where the critical section
+* runs without mutual exclusion, which can cause data loss (e.g., lost ID
+* mappings during concurrent `tbd create`).
 *
-* If the lock cannot be acquired within the timeout (e.g., due to a stuck
-* lockfile that isn't old enough to break), the critical section runs anyway.
-* Callers should design their critical sections to be safe without the lock
-* (e.g., using read-merge-write for append-only data).
+* IMPORTANT: `timeoutMs` must be greater than `staleMs` so stale locks from
+* crashed processes are always detected and broken before the timeout expires.
 */
-const DEFAULT_TIMEOUT_MS = 2e3;
+const DEFAULT_TIMEOUT_MS = 1e4;
 const DEFAULT_POLL_MS = 50;
 const DEFAULT_STALE_MS = 5e3;
 /**
+* Error thrown when the lock cannot be acquired within the timeout.
+*/
+var LockAcquisitionError = class extends Error {
+	constructor(lockPath, timeoutMs) {
+		super(`Failed to acquire lock at ${lockPath} within ${timeoutMs}ms. Another process may be holding the lock. If this persists, delete the lock directory manually and retry.`);
+		this.name = "LockAcquisitionError";
+	}
+};
+/**
 * Execute `fn` while holding a lockfile.
 *
 * The lock is a directory at `lockPath` (typically `<target-file>.lock`).
 * Concurrent callers will wait up to `timeoutMs` for the lock, polling
 * every `pollMs`. Stale locks older than `staleMs` are broken automatically.
 *
-* If the lock cannot be acquired, `fn` is still executed (degraded mode).
-* This ensures a stuck lockfile never permanently blocks the CLI.
+* If the lock cannot be acquired within the timeout, a LockAcquisitionError
+* is thrown. This ensures mutual exclusion is never silently bypassed, which
+* prevents data loss from concurrent writes.
 *
 * @param lockPath - Path to use as the lock directory (e.g., "/path/to/ids.yml.lock")
 * @param fn - Critical section to execute under the lock
 * @param options - Timing parameters for lock acquisition
 * @returns The return value of `fn`
+* @throws LockAcquisitionError if the lock cannot be acquired within the timeout
 *
 * @example
 * ```ts
@@ -99873,10 +99891,11 @@ async function withLockfile(lockPath, fn, options) {
 		}
 		await new Promise((resolve) => setTimeout(resolve, pollMs));
 	}
+	if (!acquired) throw new LockAcquisitionError(lockPath, timeoutMs);
 	try {
 		return await fn();
 	} finally {
-		if (acquired) try {
+		try {
 			await rmdir(lockPath);
 		} catch {}
 	}
@@ -100033,8 +100052,8 @@ async function loadIdMapping(baseDir) {
 * commands run in parallel.
 *
 * The merge is safe because ID mappings are append-only — entries are never
-* intentionally removed. Even if the lock acquisition fails (degraded mode),
-* the read-merge-write provides a fallback that preserves entries from other writers.
+* intentionally removed. If the lock cannot be acquired within the timeout,
+* a LockAcquisitionError is thrown rather than proceeding without protection.
 */
 async function saveIdMapping(baseDir, mapping) {
 	const filePath = getMappingPath(baseDir);
@@ -104603,11 +104622,18 @@ var DoctorHandler = class extends BaseCommand {
 		healthChecks.push(await this.checkIdMappingDuplicates(options.fix));
 		healthChecks.push(await this.checkTempFiles(options.fix));
 		healthChecks.push(this.checkIssueValidity(this.issues));
+		healthChecks.push(await this.checkWorktree(options.fix));
+		const dataLocationResult = await this.checkDataLocation(options.fix);
+		healthChecks.push(dataLocationResult);
+		if (dataLocationResult.status === "ok" && dataLocationResult.message?.includes("migrated")) {
+			this.dataSyncDir = await resolveDataSyncDir(this.cwd);
+			try {
+				this.issues = await listIssues(this.dataSyncDir);
+			} catch {}
+		}
 		const parsedMaxHistory = options.maxHistory ? parseInt(options.maxHistory, 10) : 50;
 		const maxHistory = Number.isNaN(parsedMaxHistory) || parsedMaxHistory < 0 ? 50 : parsedMaxHistory;
 		healthChecks.push(await this.checkMissingMappings(options.fix, maxHistory));
-		healthChecks.push(await this.checkWorktree(options.fix));
-		healthChecks.push(await this.checkDataLocation(options.fix));
 		healthChecks.push(await this.checkLocalSyncBranch());
 		healthChecks.push(await this.checkRemoteSyncBranch());
 		healthChecks.push(await this.checkLocalVsRemoteData());