get-tbd 0.1.21 → 0.1.23

package/dist/config-CB1tcqTZ.mjs

@@ -0,0 +1,3 @@
+import { a as isInitialized, c as readConfigWithMigration, d as writeConfig, f as writeLocalState, i as initConfig, l as readLocalState, n as findTbdRoot, o as markWelcomeSeen, r as hasSeenWelcome, s as readConfig, t as IncompatibleFormatError, u as updateLocalState } from "./config-CmEAGaxz.mjs";
+
+export { readConfig };

package/dist/config-CmEAGaxz.mjs

@@ -0,0 +1,637 @@
+import { A as LOCAL_STATE_FIELD_ORDER, a as stringifyYaml, h as ConfigSchema, i as sortKeys, j as LocalStateSchema, m as CONFIG_FIELD_ORDER } from "./yaml-utils-U7l9hhkh.mjs";
+import { parse } from "yaml";
+import { access, mkdir, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, parse as parse$1 } from "node:path";
+import { writeFile } from "atomically";
+import { homedir } from "node:os";
+
+//#region src/lib/paths.ts
+/**
+* Centralized path constants for tbd.
+*
+* Directory structure (per spec):
+*
+* On main/dev branches:
+*   .tbd/
+*     Committed to the repo:
+*       config.yml            - Project configuration
+*       .gitignore            - Controls what's gitignored below
+*       workspaces/           - Persistent state (outbox, named workspaces)
+*     Gitignored (local only):
+*       state.yml             - Local state
+*       docs/                 - Installed documentation (regenerated on setup)
+*       data-sync-worktree/   - Hidden worktree checkout of tbd-sync branch
+*         .tbd/data-sync/     - issues/, mappings/, attic/, meta.yml
+*
+* On tbd-sync branch:
+*   .tbd/
+*     data-sync/
+*       issues/
+*       mappings/
+*       attic/
+*       meta.yml
+*/
+/** The tbd configuration directory on main branch */
+const TBD_DIR = ".tbd";
+/** The config file path */
+const CONFIG_FILE = join(TBD_DIR, "config.yml");
+/** The local state file (gitignored) */
+const STATE_FILE = join(TBD_DIR, "state.yml");
+/** The worktree directory name */
+const WORKTREE_DIR_NAME = "data-sync-worktree";
+/** The worktree path (gitignored) */
+const WORKTREE_DIR = join(TBD_DIR, WORKTREE_DIR_NAME);
+/** The data directory name on the sync branch */
+const DATA_SYNC_DIR_NAME = "data-sync";
+/**
+* The base directory for synced data.
+*
+* NOTE: This is currently pointing directly to .tbd/data-sync/ which is WRONG
+* per the spec. The correct path should be via the worktree:
+*   .tbd/data-sync-worktree/.tbd/data-sync/
+*
+* TODO(tbd-208): Update this to use the worktree path once worktree
+* management is implemented.
+*/
+const DATA_SYNC_DIR = join(TBD_DIR, DATA_SYNC_DIR_NAME);
+/**
+* The correct path for synced data via worktree (per spec).
+* Use this once worktree management is implemented.
+*/
+const DATA_SYNC_DIR_VIA_WORKTREE = join(WORKTREE_DIR, TBD_DIR, DATA_SYNC_DIR_NAME);
+/** Issues directory */
+const ISSUES_DIR = join(DATA_SYNC_DIR, "issues");
+/** Mappings directory */
+const MAPPINGS_DIR = join(DATA_SYNC_DIR, "mappings");
+/** Attic directory for conflict resolution */
+const ATTIC_DIR = join(DATA_SYNC_DIR, "attic");
+/** Meta file for schema version */
+const META_FILE = join(DATA_SYNC_DIR, "meta.yml");
+/** The sync branch name */
+const SYNC_BRANCH = "tbd-sync";
+/** The workspaces directory name within .tbd/ */
+const WORKSPACES_DIR_NAME = "workspaces";
+/** Full path to workspaces directory: .tbd/workspaces/ */
+const WORKSPACES_DIR = join(TBD_DIR, WORKSPACES_DIR_NAME);
+/**
+* Get the path to a named workspace directory.
+*
+* Workspaces are stored at: .tbd/workspaces/{name}/
+*
+* @param workspaceName - The name of the workspace (e.g., 'outbox', 'my-feature')
+* @returns Path to the workspace directory
+*/
+function getWorkspaceDir(workspaceName) {
+	return join(WORKSPACES_DIR, workspaceName);
+}
+/**
+* Validate a workspace name.
+*
+* Valid workspace names:
+* - Lowercase alphanumeric characters
+* - Hyphens and underscores allowed
+* - Must not be empty
+* - Must not contain path separators or dots at start
+*
+* @param name - The workspace name to validate
+* @returns true if the name is valid
+*/
+function isValidWorkspaceName(name) {
+	if (!name || name.length === 0) return false;
+	if (name.startsWith(".")) return false;
+	return /^[a-z0-9][a-z0-9_-]*$/.test(name);
+}
+/** Docs directory name within .tbd/ */
+const DOCS_DIR = "docs";
+/** Shortcuts directory name within docs/ */
+const SHORTCUTS_DIR = "shortcuts";
+/** System shortcuts directory name (core docs like skill-baseline.md) */
+const SYSTEM_DIR = "system";
+/** Standard shortcuts directory name (workflow shortcuts) */
+const STANDARD_DIR = "standard";
+/** Guidelines directory name (coding rules and best practices) */
+const GUIDELINES_DIR = "guidelines";
+/** Templates directory name (document templates) */
+const TEMPLATES_DIR = "templates";
+/** Full path to docs directory: .tbd/docs/ */
+const TBD_DOCS_DIR = join(TBD_DIR, DOCS_DIR);
+/** Full path to shortcuts directory: .tbd/docs/shortcuts/ */
+const TBD_SHORTCUTS_DIR = join(TBD_DOCS_DIR, SHORTCUTS_DIR);
+/** Full path to system shortcuts: .tbd/docs/shortcuts/system/ */
+const TBD_SHORTCUTS_SYSTEM = join(TBD_SHORTCUTS_DIR, SYSTEM_DIR);
+/** Full path to standard shortcuts: .tbd/docs/shortcuts/standard/ */
+const TBD_SHORTCUTS_STANDARD = join(TBD_SHORTCUTS_DIR, STANDARD_DIR);
+/** Full path to guidelines: .tbd/docs/guidelines/ (top-level, not under shortcuts) */
+const TBD_GUIDELINES_DIR = join(TBD_DOCS_DIR, GUIDELINES_DIR);
+/** Full path to templates: .tbd/docs/templates/ (top-level, not under shortcuts) */
+const TBD_TEMPLATES_DIR = join(TBD_DOCS_DIR, TEMPLATES_DIR);
+/** Built-in docs source paths (relative to package docs/) */
+const BUILTIN_SHORTCUTS_SYSTEM = join(SHORTCUTS_DIR, SYSTEM_DIR);
+const BUILTIN_SHORTCUTS_STANDARD = join(SHORTCUTS_DIR, STANDARD_DIR);
+/**
+* Default shortcut lookup paths (searched in order, relative to tbd root).
+* Earlier paths take precedence over later paths.
+* Note: Guidelines and templates are now separate top-level directories.
+*/
+const DEFAULT_SHORTCUT_PATHS = [TBD_SHORTCUTS_SYSTEM, TBD_SHORTCUTS_STANDARD];
+/**
+* Default guidelines lookup paths (relative to tbd root).
+*/
+const DEFAULT_GUIDELINES_PATHS = [TBD_GUIDELINES_DIR];
+/**
+* Default template lookup paths (relative to tbd root).
+*/
+const DEFAULT_TEMPLATE_PATHS = [TBD_TEMPLATES_DIR];
+/**
+* Error thrown when worktree is missing and fallback is not allowed.
+* Defined inline to avoid circular dependency with errors.ts.
+*/
+var WorktreeMissingError = class extends Error {
+	constructor(message = "Worktree not found at .tbd/data-sync-worktree/. Run 'tbd doctor --fix' to repair.") {
+		super(message);
+		this.name = "WorktreeMissingError";
+	}
+};
+/**
+* Cache for resolved data sync directory.
+* Reset when baseDir changes.
+*/
+let _resolvedDataSyncDir = null;
+let _resolvedBaseDir = null;
+let _resolvedAllowFallback = null;
+/**
+* Resolve the actual data sync directory path.
+*
+* This function detects whether we're running with a git worktree
+* (production) or in a test environment without worktree.
+*
+* Order of preference:
+* 1. Worktree path if worktree exists: .tbd/data-sync-worktree/.tbd/data-sync/
+* 2. Direct path as fallback (only if allowFallback: true)
+*
+* @param baseDir - The tbd root directory (from requireInit or findTbdRoot)
+* @param options - Options for path resolution
+* @returns Resolved data sync directory path
+* @throws WorktreeMissingError if worktree missing and allowFallback is false
+*
+* See: plan-2026-01-28-sync-worktree-recovery-and-hardening.md
+*/
+async function resolveDataSyncDir(baseDir, options) {
+	const allowFallback = options?.allowFallback ?? true;
+	if (_resolvedDataSyncDir && _resolvedBaseDir === baseDir && _resolvedAllowFallback === allowFallback) return _resolvedDataSyncDir;
+	const worktreePath = join(baseDir, DATA_SYNC_DIR_VIA_WORKTREE);
+	const directPath = join(baseDir, DATA_SYNC_DIR);
+	try {
+		await access(worktreePath);
+		_resolvedDataSyncDir = worktreePath;
+		_resolvedBaseDir = baseDir;
+		_resolvedAllowFallback = allowFallback;
+		return worktreePath;
+	} catch {
+		if (!allowFallback) throw new WorktreeMissingError();
+		if (process.env.DEBUG || process.env.TBD_DEBUG) console.warn("[tbd:paths] resolveDataSyncDir: worktree not found, falling back to direct path");
+		_resolvedDataSyncDir = directPath;
+		_resolvedBaseDir = baseDir;
+		_resolvedAllowFallback = allowFallback;
+		return directPath;
+	}
+}
+/**
+* Resolve attic directory path.
+*/
+async function resolveAtticDir(baseDir, options) {
+	return join(await resolveDataSyncDir(baseDir, options), "attic");
+}
+/**
+* Characters per token ratio for estimating token counts.
+*
+* Based on research of OpenAI (tiktoken) and Claude tokenizers:
+* - Pure English prose: ~4-5 chars/token
+* - Code and symbols: ~3 chars/token
+* - Mixed markdown/code docs: ~3.5 chars/token
+*
+* We use 3.5 as our docs are markdown with code examples.
+* This provides ~15-20% accuracy, sufficient for cost estimation.
+*/
+const CHARS_PER_TOKEN = 3.5;
+
+//#endregion
+//#region src/lib/tbd-format.ts
+/**
+* tbd Directory Format Versioning
+* ================================
+*
+* This file is the SINGLE SOURCE OF TRUTH for .tbd/ directory format versions.
+*
+* WHEN TO BUMP THE FORMAT VERSION:
+* - Bump when changes REQUIRE migration (deleting files, changing formats, moving files)
+* - **Bump when changing config schema** (adding, removing, or modifying fields)
+* - Do NOT bump for additive changes that don't affect config.yml (new directories, etc.)
+*
+* HOW TO ADD A NEW FORMAT VERSION:
+* 1. Add entry to FORMAT_HISTORY with detailed description
+* 2. Implement migrate_fXX_to_fYY() function
+* 3. Add case to migrateToLatest()
+* 4. Update CURRENT_FORMAT
+* 5. Add tests for the migration path
+*
+* FORWARD COMPATIBILITY POLICY:
+* ConfigSchema uses Zod's strip() mode, which discards unknown fields. To prevent
+* data loss when users mix tbd versions:
+*
+* 1. When changing config schema, bump the format version (e.g., f03 → f04)
+* 2. config.ts checks format compatibility via isCompatibleFormat()
+* 3. Older tbd versions will error with "format 'fXX' is from a newer tbd version"
+* 4. The error tells users to upgrade: npm install -g get-tbd@latest
+*
+* This ensures older versions fail fast rather than silently corrupting config.
+* See ConfigSchema in schemas.ts and checkFormatCompatibility() in config.ts.
+*/
+/**
+* Current format version.
+* Bump this ONLY for breaking changes that require migration.
+*/
+const CURRENT_FORMAT = "f03";
+/**
+* Initial format version for configs that don't have tbd_format field.
+*/
+const INITIAL_FORMAT = "f01";
+/**
+* Complete history of format versions with their changes.
+* This serves as documentation and enables version detection.
+*/
+const FORMAT_HISTORY = {
+	f01: {
+		introduced: "0.1.0",
+		description: "Initial format",
+		structure: {
+			"config.yml": "Project configuration",
+			"state.yml": "Local state (gitignored)",
+			"docs/": "Documentation cache (gitignored)",
+			"issues/": "Issue YAML files"
+		}
+	},
+	f02: {
+		introduced: "0.1.5",
+		description: "Adds configurable doc_cache",
+		changes: [
+			"Added doc_cache: key to config.yml for configurable doc sources",
+			"Added settings.doc_auto_sync_hours for automatic doc refresh",
+			"Added last_doc_sync_at to state.yml for tracking sync time"
+		],
+		migration: "Populates default doc_cache config from bundled docs"
+	},
+	f03: {
+		introduced: "0.1.6",
+		description: "Consolidates docs_cache config structure",
+		changes: [
+			"Consolidated doc_cache: and docs: into single docs_cache: key",
+			"Moved doc_cache: -> docs_cache.files:",
+			"Moved docs.paths: -> docs_cache.lookup_path:",
+			"Removed separate docs: key"
+		],
+		migration: "Migrates old config keys to new docs_cache structure"
+	}
+};
+/**
+* Migrate from f01 to f02.
+* - Adds tbd_format field
+* - Adds doc_auto_sync_hours setting (default: 24)
+* - doc_cache will be populated separately during setup (requires file system access)
+*/
+function migrate_f01_to_f02(config) {
+	const changes = [];
+	const migrated = { ...config };
+	migrated.tbd_format = "f02";
+	changes.push("Added tbd_format: f02");
+	migrated.settings ??= {};
+	if (migrated.settings.doc_auto_sync_hours === void 0) {
+		migrated.settings.doc_auto_sync_hours = 24;
+		changes.push("Added settings.doc_auto_sync_hours: 24");
+	}
+	return {
+		config: migrated,
+		fromFormat: "f01",
+		toFormat: "f02",
+		changed: changes.length > 0,
+		changes
+	};
+}
+/**
+* Migrate from f02 to f03.
+* - Consolidates doc_cache: and docs: into docs_cache:
+* - Moves doc_cache: -> docs_cache.files:
+* - Moves docs.paths: -> docs_cache.lookup_path:
+* - Removes separate docs: and doc_cache: keys
+*/
+function migrate_f02_to_f03(config) {
+	const changes = [];
+	const migrated = { ...config };
+	migrated.tbd_format = "f03";
+	changes.push("Updated tbd_format: f03");
+	migrated.docs_cache ??= {};
+	if (migrated.doc_cache && Object.keys(migrated.doc_cache).length > 0) {
+		migrated.docs_cache.files = { ...migrated.doc_cache };
+		changes.push("Moved doc_cache: -> docs_cache.files:");
+		delete migrated.doc_cache;
+	}
+	if (migrated.docs?.paths && migrated.docs.paths.length > 0) {
+		migrated.docs_cache.lookup_path = [...migrated.docs.paths];
+		changes.push("Moved docs.paths: -> docs_cache.lookup_path:");
+	}
+	if (migrated.docs) {
+		delete migrated.docs;
+		changes.push("Removed docs: key");
+	}
+	return {
+		config: migrated,
+		fromFormat: "f02",
+		toFormat: "f03",
+		changed: changes.length > 0,
+		changes
+	};
+}
+/**
+* Detect the format version of a config.
+* Returns INITIAL_FORMAT ('f01') if no tbd_format field is present.
+*/
+function detectFormat(config) {
+	const format = config.tbd_format;
+	if (!format) return INITIAL_FORMAT;
+	if (format in FORMAT_HISTORY) return format;
+	return CURRENT_FORMAT;
+}
+/**
+* Check if a config needs migration.
+*/
+function needsMigration(config) {
+	return detectFormat(config) !== CURRENT_FORMAT;
+}
+/**
+* Migrate a config to the latest format version.
+*
+* This function applies all necessary migrations in sequence.
+* It does NOT populate doc_cache - that requires file system access
+* and should be done separately during setup.
+*
+* @param config - The raw config to migrate
+* @returns Migration result with the migrated config and change log
+*/
+function migrateToLatest(config) {
+	const fromFormat = detectFormat(config);
+	if (fromFormat === CURRENT_FORMAT) return {
+		config,
+		fromFormat,
+		toFormat: CURRENT_FORMAT,
+		changed: false,
+		changes: []
+	};
+	let current = config;
+	let currentFormat = fromFormat;
+	const allChanges = [];
+	if (currentFormat === "f01") {
+		const result = migrate_f01_to_f02(current);
+		current = result.config;
+		currentFormat = "f02";
+		allChanges.push(...result.changes);
+	}
+	if (currentFormat === "f02") {
+		const result = migrate_f02_to_f03(current);
+		current = result.config;
+		currentFormat = "f03";
+		allChanges.push(...result.changes);
+	}
+	return {
+		config: current,
+		fromFormat,
+		toFormat: currentFormat,
+		changed: allChanges.length > 0,
+		changes: allChanges
+	};
+}
+/**
+* Check if a format version is compatible with the current tbd version.
+* Future format versions are considered incompatible (would need tbd upgrade).
+*/
+function isCompatibleFormat(format) {
+	const formatVersions = Object.keys(FORMAT_HISTORY);
+	const currentIndex = formatVersions.indexOf(CURRENT_FORMAT);
+	const checkIndex = formatVersions.indexOf(format);
+	if (checkIndex === -1) return false;
+	return checkIndex <= currentIndex;
+}
+
+//#endregion
+//#region src/file/config.ts
+/**
+* Config file operations.
+*
+* Config is stored at .tbd/config.yml and contains project-level settings.
+*
+* ⚠️ FORMAT VERSIONING: See tbd-format.ts for version history and migration rules.
+*
+* See: tbd-design.md §2.2.2 Config File
+*/
+/**
+* Error thrown when the config format version is from a newer tbd version.
+* This prevents older tbd versions from silently stripping new config fields.
+*/
+var IncompatibleFormatError = class extends Error {
+	constructor(foundFormat, supportedFormat) {
+		super(`Config format '${foundFormat}' is from a newer tbd version.\nThis tbd version supports up to format '${supportedFormat}'.\nPlease upgrade tbd: npm install -g get-tbd@latest`);
+		this.foundFormat = foundFormat;
+		this.supportedFormat = supportedFormat;
+		this.name = "IncompatibleFormatError";
+	}
+};
+/**
+* Check if config format is compatible, throw if not.
+* This prevents older tbd versions from silently stripping fields added by newer versions.
+*/
+function checkFormatCompatibility(data) {
+	const format = data.tbd_format;
+	if (format && !isCompatibleFormat(format)) throw new IncompatibleFormatError(format, CURRENT_FORMAT);
+}
+/**
+* Create default config for a new project.
+* @param prefix - Required: the project prefix for display IDs (e.g., "proj", "myapp")
+*/
+function createDefaultConfig(version, prefix) {
+	return ConfigSchema.parse({
+		tbd_format: CURRENT_FORMAT,
+		tbd_version: version,
+		sync: {
+			branch: SYNC_BRANCH,
+			remote: "origin"
+		},
+		display: { id_prefix: prefix },
+		settings: {
+			auto_sync: false,
+			doc_auto_sync_hours: 24
+		}
+	});
+}
+/**
+* Initialize a new config file with default settings.
+* Creates .tbd directory if it doesn't exist.
+* @param prefix - Required: the project prefix for display IDs (e.g., "proj", "myapp")
+*/
+async function initConfig(baseDir, version, prefix) {
+	await mkdir(join(baseDir, ".tbd"), { recursive: true });
+	const config = createDefaultConfig(version, prefix);
+	await writeConfig(baseDir, config);
+	return config;
+}
+/**
+* Read config from file with automatic migration if needed.
+*
+* ⚠️ FORMAT VERSIONING: See tbd-format.ts for version history and migration rules.
+*
+* @throws {IncompatibleFormatError} If config is from a newer tbd version.
+* @throws If config file doesn't exist or is invalid.
+*/
+async function readConfig(baseDir) {
+	const data = parse(await readFile(join(baseDir, CONFIG_FILE), "utf-8"));
+	checkFormatCompatibility(data);
+	if (needsMigration(data)) {
+		const result = migrateToLatest(data);
+		return ConfigSchema.parse(result.config);
+	}
+	return ConfigSchema.parse(data);
+}
+/**
+* Read config from file, returning migration info if a migration was applied.
+* Use this when you need to know if the config was migrated.
+*
+* @throws {IncompatibleFormatError} If config is from a newer tbd version.
+*/
+async function readConfigWithMigration(baseDir) {
+	const data = parse(await readFile(join(baseDir, CONFIG_FILE), "utf-8"));
+	checkFormatCompatibility(data);
+	if (needsMigration(data)) {
+		const result = migrateToLatest(data);
+		return {
+			config: ConfigSchema.parse(result.config),
+			migrated: result.changed,
+			changes: result.changes
+		};
+	}
+	return {
+		config: ConfigSchema.parse(data),
+		migrated: false,
+		changes: []
+	};
+}
+/**
+* Write config to file with explanatory comments.
+*/
+async function writeConfig(baseDir, config) {
+	const configPath = join(baseDir, CONFIG_FILE);
+	let content = stringifyYaml(sortKeys(config, CONFIG_FIELD_ORDER), {
+		lineWidth: 0,
+		sortMapEntries: false
+	});
+	if (config.docs_cache && Object.keys(config.docs_cache).length > 0) content = content.replace("docs_cache:", "# Documentation cache configuration.\n# files: Maps destination paths (relative to .tbd/docs/) to source locations.\n#   Sources can be:\n#   - internal: prefix for bundled docs (e.g., \"internal:shortcuts/standard/code-review-and-commit.md\")\n#   - Full URL for external docs (e.g., \"https://raw.githubusercontent.com/org/repo/main/file.md\")\n# lookup_path: Search paths for doc lookup (like shell $PATH). Earlier paths take precedence.\n#\n# To sync docs: tbd sync --docs\n# To check status: tbd sync --status\n#\n# Auto-sync: Docs are automatically synced when stale (default: every 24 hours).\n# Configure with settings.doc_auto_sync_hours (0 = disabled).\ndocs_cache:");
+	await writeFile(configPath, content);
+}
+/**
+* Check if tbd is properly initialized in the given directory.
+* Returns true only if .tbd/config.yml exists (not just a .tbd/ directory).
+*
+* This prevents spurious .tbd/ directories (e.g., containing only state.yml
+* created by a bug) from being mistaken for tbd roots. A valid tbd root
+* always has config.yml created during `tbd init`.
+*/
+async function hasTbdDir(dir) {
+	const configPath = join(dir, CONFIG_FILE);
+	try {
+		await access(configPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Find the tbd repository root by walking up the directory tree.
+* Similar to how git finds .git/ directories.
+*
+* @param startDir - Directory to start searching from
+* @returns The tbd root directory path, or null if not found
+*/
+async function findTbdRoot(startDir) {
+	let currentDir = startDir;
+	const { root } = parse$1(startDir);
+	while (currentDir !== root) {
+		if (await hasTbdDir(currentDir)) return currentDir;
+		currentDir = dirname(currentDir);
+	}
+	if (await hasTbdDir(root)) return root;
+	return null;
+}
+/**
+* Check if tbd is initialized in the given directory or any parent directory.
+* Walks up the directory tree looking for .tbd/.
+*/
+async function isInitialized(baseDir) {
+	return await findTbdRoot(baseDir) !== null;
+}
+/**
+* Read local state from .tbd/state.yml
+* Returns empty state if file doesn't exist.
+*/
+async function readLocalState(baseDir) {
+	const statePath = join(baseDir, STATE_FILE);
+	try {
+		const data = parse(await readFile(statePath, "utf-8"));
+		return LocalStateSchema.parse(data ?? {});
+	} catch {
+		return {};
+	}
+}
+/**
+* Write local state to .tbd/state.yml
+*
+* Uses `atomically` for safe writes (atomic rename, auto parent-dir creation).
+* However, we intentionally guard against .tbd/ not existing: `atomically`
+* would auto-create it, which is wrong if baseDir is a subdirectory rather
+* than the true tbd root. Only `tbd init` (via initConfig) should create .tbd/.
+*/
+async function writeLocalState(baseDir, state) {
+	const tbdDir = join(baseDir, ".tbd");
+	try {
+		await access(tbdDir);
+	} catch {
+		throw new Error(`Cannot write state: .tbd/ directory does not exist at ${baseDir}. Run 'tbd init' first or ensure the correct tbd root is being used.`);
+	}
+	await writeFile(join(baseDir, STATE_FILE), stringifyYaml(sortKeys(state, LOCAL_STATE_FIELD_ORDER), {
+		lineWidth: 0,
+		sortMapEntries: false
+	}));
+}
+/**
+* Update specific fields in local state (merge with existing).
+*/
+async function updateLocalState(baseDir, updates) {
+	const updated = {
+		...await readLocalState(baseDir),
+		...updates
+	};
+	await writeLocalState(baseDir, updated);
+	return updated;
+}
+/**
+* Check if the user has seen the welcome message.
+*/
+async function hasSeenWelcome(baseDir) {
+	return (await readLocalState(baseDir)).welcome_seen === true;
+}
+/**
+* Mark the welcome message as seen.
+*/
+async function markWelcomeSeen(baseDir) {
+	await updateLocalState(baseDir, { welcome_seen: true });
+}
+
+//#endregion
+export { isValidWorkspaceName as A, TBD_SHORTCUTS_STANDARD as C, WORKTREE_DIR as D, WORKSPACES_DIR as E, resolveDataSyncDir as M, WORKTREE_DIR_NAME as O, TBD_GUIDELINES_DIR as S, TBD_TEMPLATES_DIR as T, DEFAULT_SHORTCUT_PATHS as _, isInitialized as a, TBD_DIR as b, readConfigWithMigration as c, writeConfig as d, writeLocalState as f, DEFAULT_GUIDELINES_PATHS as g, DATA_SYNC_DIR_NAME as h, initConfig as i, resolveAtticDir as j, getWorkspaceDir as k, readLocalState as l, DATA_SYNC_DIR as m, findTbdRoot as n, markWelcomeSeen as o, CHARS_PER_TOKEN as p, hasSeenWelcome as r, readConfig as s, IncompatibleFormatError as t, updateLocalState as u, DEFAULT_TEMPLATE_PATHS as v, TBD_SHORTCUTS_SYSTEM as w, TBD_DOCS_DIR as x, SYNC_BRANCH as y };
+//# sourceMappingURL=config-CmEAGaxz.mjs.map