@codewalla_india/openspec 1.0.1

package/dist/core/config-schema.js

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+/**
+ * Zod schema for global OpenSpec configuration.
+ * Uses passthrough() to preserve unknown fields for forward compatibility.
+ */
+export const GlobalConfigSchema = z
+    .object({
+    featureFlags: z
+        .record(z.string(), z.boolean())
+        .optional()
+        .default({}),
+    profile: z
+        .enum(['core', 'custom'])
+        .optional()
+        .default('core'),
+    delivery: z
+        .enum(['both', 'skills', 'commands'])
+        .optional()
+        .default('both'),
+    workflows: z
+        .array(z.string())
+        .optional(),
+})
+    .passthrough();
+/**
+ * Default configuration values.
+ */
+export const DEFAULT_CONFIG = {
+    featureFlags: {},
+    profile: 'core',
+    delivery: 'both',
+};
+const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows']);
+/**
+ * Validate a config key path for CLI set operations.
+ * Unknown top-level keys are rejected unless explicitly allowed by the caller.
+ */
+export function validateConfigKeyPath(path) {
+    const rawKeys = path.split('.');
+    if (rawKeys.length === 0 || rawKeys.some((key) => key.trim() === '')) {
+        return { valid: false, reason: 'Key path must not be empty' };
+    }
+    const rootKey = rawKeys[0];
+    if (!KNOWN_TOP_LEVEL_KEYS.has(rootKey)) {
+        return { valid: false, reason: `Unknown top-level key "${rootKey}"` };
+    }
+    if (rootKey === 'featureFlags') {
+        if (rawKeys.length > 2) {
+            return { valid: false, reason: 'featureFlags values are booleans and do not support nested keys' };
+        }
+        return { valid: true };
+    }
+    if (rawKeys.length > 1) {
+        return { valid: false, reason: `"${rootKey}" does not support nested keys` };
+    }
+    return { valid: true };
+}
+/**
+ * Get a nested value from an object using dot notation.
+ *
+ * @param obj - The object to access
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns The value at the path, or undefined if not found
+ */
+export function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * Set a nested value in an object using dot notation.
+ * Creates intermediate objects as needed.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @param value - The value to set
+ */
+export function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+}
+/**
+ * Delete a nested value from an object using dot notation.
+ *
+ * @param obj - The object to modify (mutated in place)
+ * @param path - Dot-separated path (e.g., "featureFlags.someFlag")
+ * @returns true if the key existed and was deleted, false otherwise
+ */
+export function deleteNestedValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined || current[key] === null || typeof current[key] !== 'object') {
+            return false;
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    if (lastKey in current) {
+        delete current[lastKey];
+        return true;
+    }
+    return false;
+}
+/**
+ * Coerce a string value to its appropriate type.
+ * - "true" / "false" -> boolean
+ * - Numeric strings -> number
+ * - JSON arrays/objects -> parsed containers
+ * - Everything else -> string
+ *
+ * @param value - The string value to coerce
+ * @param forceString - If true, always return the value as a string
+ * @returns The coerced value
+ */
+export function coerceValue(value, forceString = false) {
+    if (forceString) {
+        return value;
+    }
+    // Boolean coercion
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    // Number coercion - must be a valid finite number
+    const num = Number(value);
+    if (!isNaN(num) && isFinite(num) && value.trim() !== '') {
+        return num;
+    }
+    const jsonContainer = parseJsonContainer(value);
+    if (jsonContainer !== undefined) {
+        return jsonContainer;
+    }
+    return value;
+}
+function parseJsonContainer(value) {
+    const trimmed = value.trim();
+    const looksLikeContainer = (trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+        (trimmed.startsWith('{') && trimmed.endsWith('}'));
+    if (!looksLikeContainer) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+        if (parsed !== null && typeof parsed === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Format a value for YAML-like display.
+ *
+ * @param value - The value to format
+ * @param indent - Current indentation level
+ * @returns Formatted string
+ */
+export function formatValueYaml(value, indent = 0) {
+    const indentStr = '  '.repeat(indent);
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+        return value.map((item) => `${indentStr}- ${formatValueYaml(item, indent + 1)}`).join('\n');
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return '{}';
+        }
+        return entries
+            .map(([key, val]) => {
+            const formattedVal = formatValueYaml(val, indent + 1);
+            if (typeof val === 'object' && val !== null && Object.keys(val).length > 0) {
+                return `${indentStr}${key}:\n${formattedVal}`;
+            }
+            return `${indentStr}${key}: ${formattedVal}`;
+        })
+            .join('\n');
+    }
+    return String(value);
+}
+/**
+ * Validate a configuration object against the schema.
+ *
+ * @param config - The configuration to validate
+ * @returns Validation result with success status and optional error message
+ */
+export function validateConfig(config) {
+    try {
+        GlobalConfigSchema.parse(config);
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            const zodError = error;
+            const messages = zodError.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
+            return { success: false, error: messages.join('; ') };
+        }
+        return { success: false, error: 'Unknown validation error' };
+    }
+}
+//# sourceMappingURL=config-schema.js.map

package/dist/core/config.d.ts

@@ -0,0 +1,18 @@
+export declare const OPENSPEC_DIR_NAME = "openspec";
+export declare const OPENSPEC_MARKERS: {
+    start: string;
+    end: string;
+};
+export interface OpenSpecConfig {
+    aiTools: string[];
+}
+export interface AIToolOption {
+    name: string;
+    value: string;
+    available: boolean;
+    successLabel?: string;
+    skillsDir?: string;
+    detectionPaths?: string[];
+}
+export declare const AI_TOOLS: AIToolOption[];
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -0,0 +1,39 @@
+export const OPENSPEC_DIR_NAME = 'openspec';
+export const OPENSPEC_MARKERS = {
+    start: '<!-- OPENSPEC:START -->',
+    end: '<!-- OPENSPEC:END -->'
+};
+export const AI_TOOLS = [
+    { name: 'Amazon Q Developer', value: 'amazon-q', available: true, successLabel: 'Amazon Q Developer', skillsDir: '.amazonq' },
+    { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity', skillsDir: '.agent' },
+    { name: 'Auggie (Augment CLI)', value: 'auggie', available: true, successLabel: 'Auggie', skillsDir: '.augment' },
+    { name: 'Bob Shell', value: 'bob', available: true, successLabel: 'Bob Shell', skillsDir: '.bob' },
+    { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code', skillsDir: '.claude' },
+    { name: 'Cline', value: 'cline', available: true, successLabel: 'Cline', skillsDir: '.cline' },
+    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.codex' },
+    { name: 'ForgeCode', value: 'forgecode', available: true, successLabel: 'ForgeCode', skillsDir: '.forge' },
+    { name: 'CodeBuddy Code (CLI)', value: 'codebuddy', available: true, successLabel: 'CodeBuddy Code', skillsDir: '.codebuddy' },
+    { name: 'Continue', value: 'continue', available: true, successLabel: 'Continue (VS Code / JetBrains / Cli)', skillsDir: '.continue' },
+    { name: 'CoStrict', value: 'costrict', available: true, successLabel: 'CoStrict', skillsDir: '.cospec' },
+    { name: 'Crush', value: 'crush', available: true, successLabel: 'Crush', skillsDir: '.crush' },
+    { name: 'Cursor', value: 'cursor', available: true, successLabel: 'Cursor', skillsDir: '.cursor' },
+    { name: 'Factory Droid', value: 'factory', available: true, successLabel: 'Factory Droid', skillsDir: '.factory' },
+    { name: 'Gemini CLI', value: 'gemini', available: true, successLabel: 'Gemini CLI', skillsDir: '.gemini' },
+    { name: 'GitHub Copilot', value: 'github-copilot', available: true, successLabel: 'GitHub Copilot', skillsDir: '.github', detectionPaths: ['.github/copilot-instructions.md', '.github/instructions', '.github/workflows/copilot-setup-steps.yml', '.github/prompts', '.github/agents', '.github/skills', '.github/.mcp.json'] },
+    { name: 'iFlow', value: 'iflow', available: true, successLabel: 'iFlow', skillsDir: '.iflow' },
+    { name: 'Junie', value: 'junie', available: true, successLabel: 'Junie', skillsDir: '.junie' },
+    { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code', skillsDir: '.kilocode' },
+    { name: 'Kimi CLI', value: 'kimi', available: true, successLabel: 'Kimi CLI', skillsDir: '.kimi' },
+    { name: 'Kiro', value: 'kiro', available: true, successLabel: 'Kiro', skillsDir: '.kiro' },
+    { name: 'Lingma', value: 'lingma', available: true, successLabel: 'Lingma', skillsDir: '.lingma' },
+    { name: 'Mistral Vibe', value: 'vibe', available: true, successLabel: 'Mistral Vibe', skillsDir: '.vibe' },
+    { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode', skillsDir: '.opencode' },
+    { name: 'Pi', value: 'pi', available: true, successLabel: 'Pi', skillsDir: '.pi' },
+    { name: 'Qoder', value: 'qoder', available: true, successLabel: 'Qoder', skillsDir: '.qoder' },
+    { name: 'Qwen Code', value: 'qwen', available: true, successLabel: 'Qwen Code', skillsDir: '.qwen' },
+    { name: 'RooCode', value: 'roocode', available: true, successLabel: 'RooCode', skillsDir: '.roo' },
+    { name: 'Trae', value: 'trae', available: true, successLabel: 'Trae', skillsDir: '.trae' },
+    { name: 'Windsurf', value: 'windsurf', available: true, successLabel: 'Windsurf', skillsDir: '.windsurf' },
+    { name: 'AGENTS.md (works with Amp, VS Code, …)', value: 'agents', available: false, successLabel: 'your AGENTS.md-compatible assistant' }
+];
+//# sourceMappingURL=config.js.map

package/dist/core/converters/json-converter.d.ts

@@ -0,0 +1,6 @@
+export declare class JsonConverter {
+    convertSpecToJson(filePath: string): string;
+    convertChangeToJson(filePath: string): Promise<string>;
+    private extractNameFromPath;
+}
+//# sourceMappingURL=json-converter.d.ts.map

package/dist/core/converters/json-converter.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { MarkdownParser } from '../parsers/markdown-parser.js';
+import { ChangeParser } from '../parsers/change-parser.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export class JsonConverter {
+    convertSpecToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const parser = new MarkdownParser(content);
+        const specName = this.extractNameFromPath(filePath);
+        const spec = parser.parseSpec(specName);
+        const jsonSpec = {
+            ...spec,
+            metadata: {
+                ...spec.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonSpec, null, 2);
+    }
+    async convertChangeToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const changeName = this.extractNameFromPath(filePath);
+        const changeDir = path.dirname(filePath);
+        const parser = new ChangeParser(content, changeDir);
+        const change = await parser.parseChangeWithDeltas(changeName);
+        const jsonChange = {
+            ...change,
+            metadata: {
+                ...change.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonChange, null, 2);
+    }
+    extractNameFromPath(filePath) {
+        const normalizedPath = FileSystemUtils.toPosixPath(filePath);
+        const parts = normalizedPath.split('/');
+        for (let i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] === 'specs' || parts[i] === 'changes') {
+                if (i < parts.length - 1) {
+                    return parts[i + 1];
+                }
+            }
+        }
+        const fileName = parts[parts.length - 1] ?? '';
+        const dotIndex = fileName.lastIndexOf('.');
+        return dotIndex > 0 ? fileName.slice(0, dotIndex) : fileName;
+    }
+}
+//# sourceMappingURL=json-converter.js.map

package/dist/core/file-state.d.ts

@@ -0,0 +1,36 @@
+import * as nodeFs from 'node:fs';
+import { StoreError } from './store/errors.js';
+/**
+ * Shared machine-local state-file mechanics (extracted from the store
+ * registry in slice 7.1, its second consumer). Callers own the
+ * diagnostic data (code, target, wording); the factory owns the
+ * shared mechanics - the fix strings describe the lock's own
+ * behavior (stale-steal, creation), so their templates live here.
+ */
+export type FileLockErrorKind = 'create-failed' | 'timeout';
+export interface FileLockErrorInfo {
+    lockPath: string;
+    /** The original errno error for 'create-failed'. */
+    cause?: unknown;
+}
+export interface FileLockOptions {
+    lockPath: string;
+    errorFor: (kind: FileLockErrorKind, info: FileLockErrorInfo) => Error;
+}
+export interface LockErrorData {
+    /** Noun phrase for the create-failed message, e.g. "the registry lock file". */
+    createSubject: string;
+    /** The full timeout message, e.g. "Store registry is busy." */
+    busyMessage: string;
+    code: string;
+    target: string;
+}
+/** One template for lock diagnostics; callers supply the data. */
+export declare function makeLockErrorFactory(data: LockErrorData): (kind: FileLockErrorKind, info: FileLockErrorInfo) => StoreError;
+export declare function isNodeErrorCode(error: unknown, code: string): boolean;
+export declare function pathIsFile(filePath: string): Promise<boolean>;
+export declare function pathIsDirectory(dirPath: string): Promise<boolean>;
+export declare function writeFileAtomically(filePath: string, content: string): Promise<void>;
+export declare function acquireFileLock(options: FileLockOptions): Promise<nodeFs.promises.FileHandle>;
+export declare function releaseFileLock(lock: nodeFs.promises.FileHandle, lockPath: string): Promise<void>;
+//# sourceMappingURL=file-state.d.ts.map

package/dist/core/file-state.js

@@ -0,0 +1,112 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { StoreError } from './store/errors.js';
+const fs = nodeFs.promises;
+/** One template for lock diagnostics; callers supply the data. */
+export function makeLockErrorFactory(data) {
+    return (kind, info) => {
+        if (kind === 'create-failed') {
+            // A permission or filesystem problem, not contention - say so.
+            return new StoreError(`Cannot create ${data.createSubject} ${info.lockPath} (${info.cause?.code ?? info.cause}).`, data.code, {
+                target: data.target,
+                fix: `Check permissions on ${path.dirname(info.lockPath)}.`,
+            });
+        }
+        return new StoreError(data.busyMessage, data.code, {
+            target: data.target,
+            fix: `Retry shortly; if this persists, delete the stale lock file ${info.lockPath}.`,
+        });
+    };
+}
+const STALE_LOCK_THRESHOLD_MS = 30_000;
+const LOCK_DEADLINE_MS = 5000;
+const LOCK_POLL_MS = 25;
+export function isNodeErrorCode(error, code) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === code);
+}
+export async function pathIsFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+// Deliberately not FileSystemUtils.directoryExists: that variant
+// debug-logs non-ENOENT failures, which is noise inside prompt
+// validators, and pathIsFile has no FileSystemUtils equivalent - the
+// silent symmetric pair lives here.
+export async function pathIsDirectory(dirPath) {
+    try {
+        return (await fs.stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function sleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export async function writeFileAtomically(filePath, content) {
+    const dirPath = path.dirname(filePath);
+    await FileSystemUtils.createDirectory(dirPath);
+    const tempPath = path.join(dirPath, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        await fs.writeFile(tempPath, content, 'utf-8');
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function acquireFileLock(options) {
+    const { lockPath, errorFor } = options;
+    const lockDir = path.dirname(lockPath);
+    await FileSystemUtils.createDirectory(lockDir);
+    if (!(await FileSystemUtils.canWriteFile(lockDir))) {
+        throw errorFor('create-failed', { lockPath, cause: 'EACCES' });
+    }
+    const deadline = Date.now() + LOCK_DEADLINE_MS;
+    while (true) {
+        try {
+            return await fs.open(lockPath, 'wx');
+        }
+        catch (error) {
+            if (!isNodeErrorCode(error, 'EEXIST')) {
+                // A permission or filesystem problem, not contention - say so.
+                throw errorFor('create-failed', { lockPath, cause: error });
+            }
+            // A crashed process leaves the lock behind forever; state-file
+            // writes are sub-second, so an old lock is an orphan - steal it.
+            let staleStolen = false;
+            try {
+                const lockStat = await fs.stat(lockPath);
+                if (Date.now() - lockStat.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
+                    await fs.rm(lockPath, { force: true });
+                    staleStolen = true;
+                }
+            }
+            catch {
+                // The holder released between open and stat - retry, but stay
+                // bounded: a persistently failing stat (EPERM, delete-pending)
+                // must hit the deadline instead of spinning forever.
+            }
+            if (!staleStolen) {
+                if (Date.now() >= deadline) {
+                    throw errorFor('timeout', { lockPath });
+                }
+                await sleep(LOCK_POLL_MS);
+            }
+        }
+    }
+}
+export async function releaseFileLock(lock, lockPath) {
+    await lock.close().catch(() => undefined);
+    await fs.rm(lockPath, { force: true }).catch(() => undefined);
+}
+//# sourceMappingURL=file-state.js.map

package/dist/core/global-config.d.ts

@@ -0,0 +1,51 @@
+export declare const GLOBAL_CONFIG_DIR_NAME = "openspec";
+export declare const GLOBAL_CONFIG_FILE_NAME = "config.json";
+export declare const GLOBAL_DATA_DIR_NAME = "openspec";
+export type Profile = 'core' | 'custom';
+export type Delivery = 'both' | 'skills' | 'commands';
+export interface GlobalConfig {
+    featureFlags?: Record<string, boolean>;
+    profile?: Profile;
+    delivery?: Delivery;
+    workflows?: string[];
+    /** Workset opener rows (slice 7.1); hand-edited, validated on use. */
+    openers?: unknown;
+}
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
+ */
+export declare function getGlobalConfigDir(): string;
+/**
+ * Gets the global data directory path following XDG Base Directory Specification.
+ * Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/openspec/
+ * - Windows fallback: %LOCALAPPDATA%/openspec/
+ */
+export interface GlobalDataDirOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    homedir?: string;
+}
+export declare function getGlobalDataDir(options?: GlobalDataDirOptions): string;
+/**
+ * Gets the path to the global config file.
+ */
+export declare function getGlobalConfigPath(): string;
+/**
+ * Loads the global configuration from disk.
+ * Returns default configuration if file doesn't exist or is invalid.
+ * Merges loaded config with defaults to ensure new fields are available.
+ */
+export declare function getGlobalConfig(): GlobalConfig;
+/**
+ * Saves the global configuration to disk.
+ * Creates the config directory if it doesn't exist.
+ */
+export declare function saveGlobalConfig(config: GlobalConfig): void;
+//# sourceMappingURL=global-config.d.ts.map

package/dist/core/global-config.js

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+// Constants
+export const GLOBAL_CONFIG_DIR_NAME = 'openspec';
+export const GLOBAL_CONFIG_FILE_NAME = 'config.json';
+export const GLOBAL_DATA_DIR_NAME = 'openspec';
+const DEFAULT_CONFIG = {
+    featureFlags: {},
+    profile: 'core',
+    delivery: 'both',
+};
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
+ */
+export function getGlobalConfigDir() {
+    // XDG_CONFIG_HOME takes precedence on all platforms when explicitly set
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        return path.join(xdgConfigHome, GLOBAL_CONFIG_DIR_NAME);
+    }
+    const platform = os.platform();
+    if (platform === 'win32') {
+        // Windows: use %APPDATA%
+        const appData = process.env.APPDATA;
+        if (appData) {
+            return path.join(appData, GLOBAL_CONFIG_DIR_NAME);
+        }
+        // Fallback for Windows if APPDATA is not set
+        return path.join(os.homedir(), 'AppData', 'Roaming', GLOBAL_CONFIG_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.config
+    return path.join(os.homedir(), '.config', GLOBAL_CONFIG_DIR_NAME);
+}
+function joinGlobalDataPath(platform, ...segments) {
+    return platform === 'win32'
+        ? path.win32.join(...segments)
+        : path.posix.join(...segments);
+}
+export function getGlobalDataDir(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? os.platform();
+    // XDG_DATA_HOME takes precedence on all platforms when explicitly set
+    const xdgDataHome = env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+        return joinGlobalDataPath(platform, xdgDataHome, GLOBAL_DATA_DIR_NAME);
+    }
+    const homedir = options.homedir ?? os.homedir();
+    if (platform === 'win32') {
+        // Windows: use %LOCALAPPDATA%
+        const localAppData = env.LOCALAPPDATA;
+        if (localAppData) {
+            return joinGlobalDataPath(platform, localAppData, GLOBAL_DATA_DIR_NAME);
+        }
+        // Fallback for Windows if LOCALAPPDATA is not set
+        return joinGlobalDataPath(platform, homedir, 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.local/share
+    return joinGlobalDataPath(platform, homedir, '.local', 'share', GLOBAL_DATA_DIR_NAME);
+}
+/**
+ * Gets the path to the global config file.
+ */
+export function getGlobalConfigPath() {
+    return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE_NAME);
+}
+/**
+ * Loads the global configuration from disk.
+ * Returns default configuration if file doesn't exist or is invalid.
+ * Merges loaded config with defaults to ensure new fields are available.
+ */
+export function getGlobalConfig() {
+    const configPath = getGlobalConfigPath();
+    try {
+        if (!fs.existsSync(configPath)) {
+            return { ...DEFAULT_CONFIG };
+        }
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Merge with defaults (loaded values take precedence)
+        const merged = {
+            ...DEFAULT_CONFIG,
+            ...parsed,
+            // Deep merge featureFlags
+            featureFlags: {
+                ...DEFAULT_CONFIG.featureFlags,
+                ...(parsed.featureFlags || {})
+            }
+        };
+        // Schema evolution: apply defaults for new fields if not present in loaded config
+        if (parsed.profile === undefined) {
+            merged.profile = DEFAULT_CONFIG.profile;
+        }
+        if (parsed.delivery === undefined) {
+            merged.delivery = DEFAULT_CONFIG.delivery;
+        }
+        return merged;
+    }
+    catch (error) {
+        // Log warning for parse errors, but not for missing files
+        if (error instanceof SyntaxError) {
+            console.error(`Warning: Invalid JSON in ${configPath}, using defaults`);
+        }
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Saves the global configuration to disk.
+ * Creates the config directory if it doesn't exist.
+ */
+export function saveGlobalConfig(config) {
+    const configDir = getGlobalConfigDir();
+    const configPath = getGlobalConfigPath();
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+//# sourceMappingURL=global-config.js.map