get-tbd 0.1.21 → 0.1.22

package/dist/bin.mjs

@@ -6734,6 +6734,12 @@ const Dependency = objectType({
 *
 * Note: Fields use .nullable() in addition to .optional() because
 * YAML parses `field: null` as JavaScript null, not undefined.
+*
+* Design note: We could add the short ID to this schema. We didn't originally
+* because it's one more field to maintain consistency around across files.
+* Having it here might make recovery of lost ID mappings far easier, but for
+* now we have more reliable management of the mappings file (ids.yml) and
+* consider it authoritative. See IdMappingYamlSchema (§2.6.8).
 */
 const IssueSchema = BaseEntity.extend({
 	type: literalType("is"),
@@ -14027,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.21";
+const VERSION$1 = "0.1.22";
 
 //#endregion
 //#region src/cli/lib/version.ts
@@ -97854,6 +97860,20 @@ function isCompatibleFormat(format) {
 *
 * See: tbd-design.md §2.2.2 Config File
 */
+var config_exports = /* @__PURE__ */ __exportAll({
+	IncompatibleFormatError: () => IncompatibleFormatError,
+	findTbdRoot: () => findTbdRoot,
+	hasSeenWelcome: () => hasSeenWelcome,
+	initConfig: () => initConfig,
+	isInitialized: () => isInitialized,
+	markWelcomeSeen: () => markWelcomeSeen,
+	readConfig: () => readConfig,
+	readConfigWithMigration: () => readConfigWithMigration,
+	readLocalState: () => readLocalState,
+	updateLocalState: () => updateLocalState,
+	writeConfig: () => writeConfig,
+	writeLocalState: () => writeLocalState
+});
 /**
 * Error thrown when the config format version is from a newer tbd version.
 * This prevents older tbd versions from silently stripping new config fields.
@@ -99852,11 +99872,13 @@ function naturalSort(arr) {
 var id_mapping_exports = /* @__PURE__ */ __exportAll({
 	addIdMapping: () => addIdMapping,
 	calculateOptimalLength: () => calculateOptimalLength,
+	createShortIdMapping: () => createShortIdMapping,
 	generateUniqueShortId: () => generateUniqueShortId,
 	hasShortId: () => hasShortId,
 	loadIdMapping: () => loadIdMapping,
 	mergeIdMappings: () => mergeIdMappings,
 	parseIdMappingFromYaml: () => parseIdMappingFromYaml,
+	reconcileMappings: () => reconcileMappings,
 	resolveToInternalId: () => resolveToInternalId,
 	saveIdMapping: () => saveIdMapping
 });
@@ -99955,6 +99977,22 @@ function hasShortId(mapping, shortId) {
 	return mapping.shortToUlid.has(shortId);
 }
 /**
+* Create a short ID mapping for a new internal ID.
+* Generates a unique short ID and registers it in the mapping.
+*
+* @param internalId - The internal ID (is-{ulid})
+* @param mapping - The ID mapping to update
+* @returns The generated short ID
+*/
+function createShortIdMapping(internalId, mapping) {
+	const ulid = extractUlidFromInternalId(internalId);
+	const existing = mapping.ulidToShort.get(ulid);
+	if (existing) return existing;
+	const shortId = generateUniqueShortId(mapping);
+	addIdMapping(mapping, ulid, shortId);
+	return shortId;
+}
+/**
 * Resolve any ID input to an internal ID ({prefix}-{ulid}).
 *
 * Handles:
@@ -100001,6 +100039,44 @@ function parseIdMappingFromYaml(content) {
 	};
 }
 /**
+* Ensure all given internal IDs have short ID mappings.
+* Creates missing mappings for any IDs without entries.
+*
+* This repairs state after git merges that may add issue files
+* without corresponding mapping entries (e.g., when outbox issues
+* are merged from a feature branch but ids.yml doesn't include them).
+*
+* When a `historicalMapping` is provided, the function will try to recover
+* the original short ID from that mapping before generating a new random one.
+* This preserves ID stability so that existing references (in docs, PRs,
+* conversations) remain valid.
+*
+* @param internalIds - Array of internal IDs (is-{ulid}) to reconcile
+* @param mapping - The ID mapping to update (mutated in-place)
+* @param historicalMapping - Optional mapping from prior state (e.g., git history) to recover original short IDs
+* @returns Object with `created` (IDs that got new random short IDs) and `recovered` (IDs restored from history)
+*/
+function reconcileMappings(internalIds, mapping, historicalMapping) {
+	const created = [];
+	const recovered = [];
+	for (const id of internalIds) {
+		const ulid = extractUlidFromInternalId(id);
+		if (mapping.ulidToShort.has(ulid)) continue;
+		const historicalShortId = historicalMapping?.ulidToShort.get(ulid);
+		if (historicalShortId && !mapping.shortToUlid.has(historicalShortId)) {
+			addIdMapping(mapping, ulid, historicalShortId);
+			recovered.push(id);
+		} else {
+			createShortIdMapping(id, mapping);
+			created.push(id);
+		}
+	}
+	return {
+		created,
+		recovered
+	};
+}
+/**
 * Merge two ID mappings by combining all entries from both.
 * ID mappings are always additive (new IDs are only added, never removed),
 * so merging simply unions all key-value pairs.
@@ -102768,6 +102844,9 @@ async function importFromWorkspace(tbdRoot, dataSyncDir, options) {
 	const sourceMapping = await loadIdMapping(sourceDir);
 	const targetMapping = await loadIdMapping(dataSyncDir);
 	for (const [shortId, ulid] of sourceMapping.shortToUlid) if (!targetMapping.shortToUlid.has(shortId)) addIdMapping(targetMapping, ulid, shortId);
+	const reconcileResult = reconcileMappings(sourceIssues.map((i) => i.id), targetMapping, sourceMapping);
+	if (reconcileResult.recovered.length > 0) log.info(`Recovered ${reconcileResult.recovered.length} ID mapping(s) from workspace`);
+	if (reconcileResult.created.length > 0) log.info(`Created ${reconcileResult.created.length} new ID mapping(s) for imported issues`);
 	await saveIdMapping(dataSyncDir, targetMapping);
 	let cleared = false;
 	if (shouldClear && imported > 0) {
@@ -103226,6 +103305,24 @@ var SyncHandler = class extends BaseCommand {
 					await git("-C", worktreePath, "merge", `${remote}/${syncBranch}`, "-m", "tbd sync: merge remote changes");
 					this.output.debug(`Merged ${behindCommits} commit(s) from remote`);
 					if (headBeforeMerge) await this.showGitLogDebug("Commits received", `${headBeforeMerge}..${syncBranch}`);
+					const postMergeIssues = await listIssues(this.dataSyncDir);
+					const postMergeMapping = await loadIdMapping(this.dataSyncDir);
+					let historicalMapping;
+					try {
+						const remoteIdsContent = await git("show", `${remote}/${syncBranch}:${DATA_SYNC_DIR}/mappings/ids.yml`);
+						if (remoteIdsContent) historicalMapping = parseIdMappingFromYaml(remoteIdsContent);
+					} catch {}
+					const reconcileResult = reconcileMappings(postMergeIssues.map((i) => i.id), postMergeMapping, historicalMapping);
+					const totalReconciled = reconcileResult.created.length + reconcileResult.recovered.length;
+					if (totalReconciled > 0) {
+						await saveIdMapping(this.dataSyncDir, postMergeMapping);
+						await git("-C", worktreePath, "add", "-A");
+						try {
+							await git("-C", worktreePath, "commit", "--no-verify", "-m", `tbd sync: reconcile ${totalReconciled} missing ID mapping(s)`);
+						} catch {}
+						if (reconcileResult.recovered.length > 0) this.output.debug(`Recovered ${reconcileResult.recovered.length} ID mapping(s) from history`);
+						if (reconcileResult.created.length > 0) this.output.debug(`Created ${reconcileResult.created.length} new ID mapping(s) (no history available)`);
+					}
 				} catch {
 					this.output.info(`Merge conflict, attempting file-level resolution`);
 					const localIssues = await listIssues(this.dataSyncDir);
@@ -103238,18 +103335,29 @@ var SyncHandler = class extends BaseCommand {
 					} catch {
 						this.output.debug(`Issue ${localIssue.id} not on remote, keeping local`);
 					}
+					let conflictRemoteMapping;
 					try {
 						const remoteIdsContent = await git("show", `${remote}/${syncBranch}:${DATA_SYNC_DIR}/mappings/ids.yml`);
 						if (remoteIdsContent) {
+							conflictRemoteMapping = parseIdMappingFromYaml(remoteIdsContent);
 							const localMapping = await loadIdMapping(this.dataSyncDir);
-							const remoteMapping = parseIdMappingFromYaml(remoteIdsContent);
-							const mergedMapping = mergeIdMappings(localMapping, remoteMapping);
+							const mergedMapping = mergeIdMappings(localMapping, conflictRemoteMapping);
 							await saveIdMapping(this.dataSyncDir, mergedMapping);
-							this.output.debug(`Merged ID mappings: ${localMapping.shortToUlid.size} local + ${remoteMapping.shortToUlid.size} remote = ${mergedMapping.shortToUlid.size} total`);
+							this.output.debug(`Merged ID mappings: ${localMapping.shortToUlid.size} local + ${conflictRemoteMapping.shortToUlid.size} remote = ${mergedMapping.shortToUlid.size} total`);
 						}
 					} catch (error) {
 						this.output.debug(`Could not merge ids.yml: ${error.message}`);
 					}
+					{
+						const allIssues = await listIssues(this.dataSyncDir);
+						const currentMapping = await loadIdMapping(this.dataSyncDir);
+						const reconcileResult = reconcileMappings(allIssues.map((i) => i.id), currentMapping, conflictRemoteMapping);
+						if (reconcileResult.created.length + reconcileResult.recovered.length > 0) {
+							await saveIdMapping(this.dataSyncDir, currentMapping);
+							if (reconcileResult.recovered.length > 0) this.output.debug(`Recovered ${reconcileResult.recovered.length} ID mapping(s) from remote`);
+							if (reconcileResult.created.length > 0) this.output.debug(`Created ${reconcileResult.created.length} new ID mapping(s) after conflict resolution`);
+						}
+					}
 					await git("-C", worktreePath, "add", "-A");
 					const conflictCheck = await git("-C", worktreePath, "diff", "--cached", "-S<<<<<<< ", "--name-only");
 					if (conflictCheck.trim()) {
@@ -104351,6 +104459,7 @@ 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.checkMissingMappings(options.fix));
 		healthChecks.push(await this.checkWorktree(options.fix));
 		healthChecks.push(await this.checkDataLocation(options.fix));
 		healthChecks.push(await this.checkLocalSyncBranch());
@@ -104694,6 +104803,63 @@ var DoctorHandler = class extends BaseCommand {
 			suggestion: "Manually fix or delete invalid issue files"
 		};
 	}
+	/**
+	* Check for issues that have no short ID mapping in ids.yml.
+	*
+	* This can happen when a git merge brings in issue files (e.g., from
+	* a feature branch with outbox issues) without the corresponding
+	* ids.yml entries. Without a mapping, any command that tries to
+	* display the issue ID will crash.
+	*
+	* With --fix, creates missing mappings automatically.
+	*/
+	async checkMissingMappings(fix) {
+		if (this.issues.length === 0) return {
+			name: "ID mapping coverage",
+			status: "ok"
+		};
+		const { loadIdMapping, saveIdMapping, reconcileMappings } = await Promise.resolve().then(() => id_mapping_exports);
+		const mapping = await loadIdMapping(this.dataSyncDir);
+		const missingIds = [];
+		for (const issue of this.issues) {
+			const ulid = extractUlidFromInternalId(issue.id);
+			if (!mapping.ulidToShort.has(ulid)) missingIds.push(issue.id);
+		}
+		if (missingIds.length === 0) return {
+			name: "ID mapping coverage",
+			status: "ok"
+		};
+		if (fix && !this.checkDryRun("Create missing ID mappings")) {
+			const { parseIdMappingFromYaml } = await Promise.resolve().then(() => id_mapping_exports);
+			let historicalMapping;
+			try {
+				const syncBranch = (await Promise.resolve().then(() => config_exports).then((m) => m.readConfig(this.cwd))).sync.branch;
+				const priorContent = await git("log", "-1", "--format=%H", syncBranch, "--", `${DATA_SYNC_DIR}/mappings/ids.yml`);
+				if (priorContent.trim()) {
+					const idsContent = await git("show", `${priorContent.trim()}:${DATA_SYNC_DIR}/mappings/ids.yml`);
+					if (idsContent) historicalMapping = parseIdMappingFromYaml(idsContent);
+				}
+			} catch {}
+			const result = reconcileMappings(missingIds, mapping, historicalMapping);
+			await saveIdMapping(this.dataSyncDir, mapping);
+			const parts = [];
+			if (result.recovered.length > 0) parts.push(`recovered ${result.recovered.length} from git history`);
+			if (result.created.length > 0) parts.push(`created ${result.created.length} new`);
+			return {
+				name: "ID mapping coverage",
+				status: "ok",
+				message: parts.join(", ")
+			};
+		}
+		return {
+			name: "ID mapping coverage",
+			status: "error",
+			message: `${missingIds.length} issue(s) without short ID mapping`,
+			details: missingIds.map((id) => `${id} (no short ID)`),
+			fixable: true,
+			suggestion: "Run: tbd doctor --fix to create missing mappings"
+		};
+	}
 	async checkClaudeSkill() {
 		const claudePaths = getClaudePaths(this.cwd);
 		try {
@@ -108468,6 +108634,13 @@ var SetupDefaultHandler = class extends BaseCommand {
 		]);
 		if (tbdGitignoreResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitignore`);
 		else if (tbdGitignoreResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitignore with new patterns`);
+		const gitattributesResult = await ensureGitignorePatterns(join(projectDir, TBD_DIR, ".gitattributes"), [
+			"# Protect ID mappings from merge deletion (always keep all rows)",
+			"# See: https://github.com/jlevy/tbd/issues/99",
+			"**/mappings/ids.yml merge=union"
+		]);
+		if (gitattributesResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitattributes (merge protection)`);
+		else if (gitattributesResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitattributes (merge protection)`);
 		console.log("Checking integrations...");
 		await new SetupAutoHandler(this.cmd).run(projectDir);
 		console.log("");
@@ -108598,6 +108771,13 @@ Example:
 		]);
 		if (tbdGitignoreResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitignore`);
 		else if (tbdGitignoreResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitignore`);
+		const gitattributesResult = await ensureGitignorePatterns(join(cwd, TBD_DIR, ".gitattributes"), [
+			"# Protect ID mappings from merge deletion (always keep all rows)",
+			"# See: https://github.com/jlevy/tbd/issues/99",
+			"**/mappings/ids.yml merge=union"
+		]);
+		if (gitattributesResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitattributes (merge protection)`);
+		else if (gitattributesResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitattributes (merge protection)`);
 		try {
 			await initWorktree(cwd);
 			const health = await checkWorktreeHealth(cwd);