@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/core/context-store/operations.js

@@ -0,0 +1,352 @@
+import { execFile } from 'node:child_process';
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { getContextStoreMetadataPath, getContextStoreRegistryPath, listContextStoreRegistryEntries, readContextStoreRegistryState, readOptionalContextStoreMetadataState, resolveGitContextStoreBackendConfig, validateContextStoreId, } from './foundation.js';
+import { ContextStoreError, makeContextStoreDiagnostic } from './errors.js';
+import { getStoreRootForBackend, assertNoRegisteredStoreConflict, commitContextStoreRegistration, listRegisteredContextStores, } from './registry.js';
+const fs = nodeFs.promises;
+const execFileAsync = promisify(execFile);
+async function pathKind(targetPath) {
+    try {
+        const stat = await fs.stat(targetPath);
+        if (stat.isDirectory())
+            return 'directory';
+        if (stat.isFile())
+            return 'file';
+        return 'other';
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return 'missing';
+        }
+        throw error;
+    }
+}
+async function isDirectoryEmpty(directory) {
+    return (await fs.readdir(directory)).length === 0;
+}
+async function readStoreMetadataForOperation(storeRoot) {
+    try {
+        return await readOptionalContextStoreMetadataState(storeRoot);
+    }
+    catch (error) {
+        throw new ContextStoreError(error instanceof Error ? error.message : String(error), 'invalid_context_store_metadata', {
+            target: 'context_store.metadata',
+            fix: `Repair ${getContextStoreMetadataPath(storeRoot)}.`,
+        });
+    }
+}
+async function isGitRepositoryAtRoot(storeRoot) {
+    const gitPath = path.join(storeRoot, '.git');
+    const kind = await pathKind(gitPath);
+    return kind === 'directory' || kind === 'file';
+}
+async function initGitRepository(storeRoot) {
+    if (await isGitRepositoryAtRoot(storeRoot)) {
+        return false;
+    }
+    try {
+        await execFileAsync('git', ['init'], { cwd: storeRoot });
+    }
+    catch (error) {
+        throw new ContextStoreError(`Failed to initialize Git repository: ${error instanceof Error ? error.message : String(error)}`, 'context_store_git_init_failed', {
+            target: 'context_store.git',
+            fix: 'Install Git or rerun setup with --no-init-git.',
+        });
+    }
+    return true;
+}
+function resolveSetupRoot(id, inputPath) {
+    if (inputPath !== undefined && inputPath.trim().length === 0) {
+        throw new ContextStoreError('Pass a non-empty --path value.', 'context_store_path_required', {
+            target: 'context_store.root',
+            fix: `pastelsdd context-store setup ${id} --path ./team-context`,
+        });
+    }
+    return path.resolve(inputPath ?? id);
+}
+function resolveRegisterRoot(inputPath) {
+    if (inputPath === undefined || inputPath.trim().length === 0) {
+        throw new ContextStoreError('Pass a context store path.', 'context_store_path_required', {
+            target: 'context_store.root',
+            fix: 'pastelsdd context-store register /path/to/context-store',
+        });
+    }
+    return path.resolve(inputPath);
+}
+function inferStoreIdFromPath(storeRoot) {
+    return validateContextStoreId(path.basename(storeRoot));
+}
+function mutationPayload(id, storeRoot, git, createdFiles) {
+    return {
+        store: {
+            id,
+            root: storeRoot,
+            metadataPath: getContextStoreMetadataPath(storeRoot),
+        },
+        registryCommit: {
+            path: getContextStoreRegistryPath(),
+        },
+        git: {
+            isRepository: git.isRepository,
+            initialized: git.initialized,
+        },
+        createdArtifacts: createdFiles,
+    };
+}
+async function prepareSetupPlan(input) {
+    const id = validateContextStoreId(input.id ?? '');
+    const storeRoot = resolveSetupRoot(id, input.path);
+    const kind = await pathKind(storeRoot);
+    if (kind === 'file' || kind === 'other') {
+        throw new ContextStoreError(`Context store setup path is not a directory: ${storeRoot}`, 'context_store_setup_path_not_directory', {
+            target: 'context_store.root',
+            fix: 'Choose an empty directory or omit --path to use ./<id>.',
+        });
+    }
+    let metadata = null;
+    let backend;
+    if (kind === 'directory') {
+        metadata = await readStoreMetadataForOperation(storeRoot);
+        if (metadata) {
+            if (metadata.id !== id) {
+                throw new ContextStoreError(`Context store metadata id '${metadata.id}' does not match requested id '${id}'.`, 'context_store_metadata_id_mismatch', {
+                    target: 'context_store.metadata',
+                    fix: `Use id '${metadata.id}' or choose a different setup path.`,
+                });
+            }
+        }
+        else if (!(await isDirectoryEmpty(storeRoot))) {
+            throw new ContextStoreError('Context store setup does not support initializing a non-empty folder yet.', 'context_store_setup_non_empty_directory', {
+                target: 'context_store.root',
+                fix: 'Create an empty folder or use context-store register for an existing context store.',
+            });
+        }
+        backend = await resolveGitContextStoreBackendConfig({ localPath: storeRoot });
+    }
+    const registry = await readContextStoreRegistryState();
+    const conflictBackend = backend ?? {
+        type: 'git',
+        local_path: FileSystemUtils.canonicalizeExistingPath(storeRoot),
+    };
+    assertNoRegisteredStoreConflict(registry, id, conflictBackend);
+    return {
+        id,
+        storeRoot,
+        kind,
+        registry,
+        ...(backend ? { backend } : {}),
+    };
+}
+export async function prepareContextStoreSetup(input) {
+    const plan = await prepareSetupPlan(input);
+    return {
+        id: plan.id,
+        root: plan.storeRoot,
+        rootKind: plan.kind,
+        registry: plan.registry,
+        ...(plan.backend ? { backend: plan.backend } : {}),
+    };
+}
+export async function setupPreparedContextStore(prepared, input = {}) {
+    const plan = {
+        id: prepared.id,
+        storeRoot: prepared.root,
+        kind: prepared.rootKind,
+        registry: prepared.registry,
+        ...(prepared.backend ? { backend: prepared.backend } : {}),
+    };
+    const { id, storeRoot, kind, registry } = plan;
+    let { backend } = plan;
+    const createdFiles = [];
+    const initGit = input.initGit ?? false;
+    if (kind === 'missing') {
+        await fs.mkdir(storeRoot, { recursive: true });
+    }
+    try {
+        backend ??= await resolveGitContextStoreBackendConfig({ localPath: storeRoot });
+        assertNoRegisteredStoreConflict(registry, id, backend);
+        const gitInitialized = initGit ? await initGitRepository(storeRoot) : false;
+        const registered = await commitContextStoreRegistration({
+            id,
+            backend,
+            writeMetadataIfMissing: true,
+        });
+        if (registered.metadataCreated) {
+            createdFiles.push('.pastelsdd-store/store.yaml');
+        }
+        const isRepository = await isGitRepositoryAtRoot(registered.storeRoot);
+        return mutationPayload(id, registered.storeRoot, {
+            isRepository,
+            initialized: gitInitialized,
+        }, createdFiles);
+    }
+    catch (error) {
+        if (kind === 'missing') {
+            await fs.rm(storeRoot, { recursive: true, force: true });
+        }
+        throw error;
+    }
+}
+export async function setupContextStore(input) {
+    return setupPreparedContextStore(await prepareContextStoreSetup(input), {
+        initGit: input.initGit,
+    });
+}
+export async function registerExistingContextStore(input) {
+    const storeRoot = resolveRegisterRoot(input.path);
+    const kind = await pathKind(storeRoot);
+    if (kind === 'missing') {
+        throw new ContextStoreError(`Context store path does not exist: ${storeRoot}`, 'context_store_path_missing', {
+            target: 'context_store.root',
+            fix: 'Clone or create the context store folder before registering it.',
+        });
+    }
+    if (kind !== 'directory') {
+        throw new ContextStoreError(`Context store path is not a directory: ${storeRoot}`, 'context_store_path_not_directory', {
+            target: 'context_store.root',
+            fix: 'Pass an existing context store directory.',
+        });
+    }
+    const metadata = await readStoreMetadataForOperation(storeRoot);
+    const explicitId = input.id !== undefined ? validateContextStoreId(input.id) : undefined;
+    if (metadata && explicitId !== undefined && metadata.id !== explicitId) {
+        throw new ContextStoreError(`Context store metadata id '${metadata.id}' does not match --id '${explicitId}'.`, 'context_store_metadata_id_mismatch', {
+            target: 'context_store.id',
+            fix: `Use --id ${metadata.id} or register a different folder.`,
+        });
+    }
+    const id = metadata?.id ?? explicitId ?? inferStoreIdFromPath(storeRoot);
+    const backend = await resolveGitContextStoreBackendConfig({ localPath: storeRoot });
+    const registry = await readContextStoreRegistryState();
+    assertNoRegisteredStoreConflict(registry, id, backend);
+    const createdFiles = [];
+    const registered = await commitContextStoreRegistration({
+        id,
+        backend,
+        writeMetadataIfMissing: true,
+    });
+    if (registered.metadataCreated) {
+        createdFiles.push('.pastelsdd-store/store.yaml');
+    }
+    return mutationPayload(id, registered.storeRoot, {
+        isRepository: await isGitRepositoryAtRoot(registered.storeRoot),
+        initialized: false,
+    }, createdFiles);
+}
+export async function listContextStores() {
+    const entries = await listRegisteredContextStores();
+    return {
+        stores: entries.map((entry) => ({
+            id: entry.id,
+            root: entry.storeRoot,
+        })),
+    };
+}
+function doctorStatusForError(error, code, target, fix) {
+    if (error instanceof ContextStoreError) {
+        return error.diagnostic;
+    }
+    return makeContextStoreDiagnostic('error', code, error instanceof Error ? error.message : String(error), {
+        target,
+        ...(fix ? { fix } : {}),
+    });
+}
+async function inspectContextStore(entry) {
+    const root = getStoreRootForBackend(entry.backend);
+    const metadataPath = getContextStoreMetadataPath(root);
+    const diagnostics = [];
+    const kind = await pathKind(root);
+    let metadata = {
+        present: null,
+        valid: null,
+    };
+    let git = {
+        isRepository: null,
+    };
+    if (kind === 'missing') {
+        diagnostics.push(makeContextStoreDiagnostic('error', 'context_store_root_missing', 'Context store location does not exist.', {
+            target: 'context_store.root',
+            fix: `Run pastelsdd context-store register /path/to/${entry.id} --id ${entry.id}.`,
+        }));
+    }
+    else if (kind !== 'directory') {
+        diagnostics.push(makeContextStoreDiagnostic('error', 'context_store_root_not_directory', 'Context store location is not a directory.', {
+            target: 'context_store.root',
+            fix: 'Register a directory path for this context store.',
+        }));
+    }
+    else {
+        try {
+            const parsed = await readOptionalContextStoreMetadataState(root);
+            if (!parsed) {
+                metadata = { present: false, valid: false };
+                diagnostics.push(makeContextStoreDiagnostic('error', 'context_store_metadata_missing', 'Context store metadata is missing.', {
+                    target: 'context_store.metadata',
+                    fix: `Create ${metadataPath} or rerun context-store register.`,
+                }));
+            }
+            else if (parsed.id !== entry.id) {
+                metadata = { present: true, valid: false, id: parsed.id };
+                diagnostics.push(makeContextStoreDiagnostic('error', 'context_store_metadata_id_mismatch', `Context store metadata id '${parsed.id}' does not match registry id '${entry.id}'.`, {
+                    target: 'context_store.metadata',
+                    fix: 'Repair the local registry or store metadata so the ids match.',
+                }));
+            }
+            else {
+                metadata = { present: true, valid: true, id: parsed.id };
+            }
+        }
+        catch (error) {
+            metadata = { present: true, valid: false };
+            diagnostics.push(doctorStatusForError(error, 'context_store_metadata_invalid', 'context_store.metadata', `Repair ${metadataPath}.`));
+        }
+        git = {
+            isRepository: await isGitRepositoryAtRoot(root),
+        };
+    }
+    return {
+        id: entry.id,
+        root,
+        metadataPath,
+        metadata,
+        git,
+        diagnostics,
+    };
+}
+export async function doctorContextStores(id) {
+    const selectedId = id !== undefined ? validateContextStoreId(id) : undefined;
+    const registry = await readContextStoreRegistryState();
+    if (!registry) {
+        if (selectedId !== undefined) {
+            throw new ContextStoreError(`Unknown context store '${selectedId}'.`, 'context_store_not_found', {
+                target: 'context_store.id',
+                fix: 'Run pastelsdd context-store list to see registered stores.',
+            });
+        }
+        return { stores: [], diagnostics: [] };
+    }
+    const entries = listContextStoreRegistryEntries(registry);
+    const selected = selectedId
+        ? entries.filter((entry) => entry.id === selectedId)
+        : entries;
+    if (selectedId && selected.length === 0) {
+        throw new ContextStoreError(`Unknown context store '${selectedId}'.`, 'context_store_not_found', {
+            target: 'context_store.id',
+            fix: 'Run pastelsdd context-store list to see registered stores.',
+        });
+    }
+    return {
+        stores: await Promise.all(selected.map(inspectContextStore)),
+        diagnostics: [],
+    };
+}
+export function normalizeContextStorePathForComparison(targetPath) {
+    return FileSystemUtils.canonicalizeExistingPath(targetPath);
+}
+//# sourceMappingURL=operations.js.map

package/dist/core/context-store/registry.d.ts

@@ -0,0 +1,35 @@
+import { type ContextStoreBackendConfig, type ContextStoreGitBackendConfig, type ContextStorePathOptions, type ContextStoreRegistryEntry, type ContextStoreRegistryState } from './foundation.js';
+export interface RegisterContextStoreInput extends ContextStorePathOptions {
+    id: string;
+    localPath: string;
+    remote?: string;
+    branch?: string;
+    cwd?: string;
+}
+export interface ResolveRegisteredContextStoreInput extends ContextStorePathOptions {
+    id: string;
+}
+export type ListRegisteredContextStoresOptions = ContextStorePathOptions;
+export interface RegisteredContextStoreEntry extends ContextStoreRegistryEntry {
+    storeRoot: string;
+}
+export interface ResolvedContextStore {
+    id: string;
+    storeRoot: string;
+    backend: ContextStoreGitBackendConfig;
+}
+export interface ContextStoreRegistrationCommit extends ResolvedContextStore {
+    metadataCreated: boolean;
+}
+export interface CommitContextStoreRegistrationInput extends ContextStorePathOptions {
+    id: string;
+    backend: ContextStoreGitBackendConfig;
+    writeMetadataIfMissing: boolean;
+}
+export declare function getStoreRootForBackend(backend: ContextStoreBackendConfig): string;
+export declare function assertNoRegisteredStoreConflict(registry: ContextStoreRegistryState | null, id: string, backend: ContextStoreGitBackendConfig): void;
+export declare function commitContextStoreRegistration(input: CommitContextStoreRegistrationInput): Promise<ContextStoreRegistrationCommit>;
+export declare function registerContextStore(input: RegisterContextStoreInput): Promise<ResolvedContextStore>;
+export declare function listRegisteredContextStores(options?: ListRegisteredContextStoresOptions): Promise<RegisteredContextStoreEntry[]>;
+export declare function resolveRegisteredContextStore(input: ResolveRegisteredContextStoreInput): Promise<ResolvedContextStore>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/context-store/registry.js

@@ -0,0 +1,158 @@
+import * as fs from 'node:fs/promises';
+import { getContextStoreMetadataPath, getContextStoreMetadataDir, listContextStoreRegistryEntries, readContextStoreRegistryState, readOptionalContextStoreMetadataState, resolveGitContextStoreBackendConfig, updateContextStoreRegistryState, validateContextStoreId, writeContextStoreMetadataState, } from './foundation.js';
+import { ContextStoreError } from './errors.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export function getStoreRootForBackend(backend) {
+    switch (backend.type) {
+        case 'git':
+            return backend.local_path;
+    }
+}
+function normalizePathForComparison(targetPath) {
+    try {
+        return FileSystemUtils.canonicalizeExistingPath(targetPath);
+    }
+    catch {
+        return targetPath;
+    }
+}
+export function assertNoRegisteredStoreConflict(registry, id, backend) {
+    const nextPath = normalizePathForComparison(getStoreRootForBackend(backend));
+    for (const entry of listContextStoreRegistryEntries(registry ?? { version: 1, stores: {} })) {
+        const entryPath = normalizePathForComparison(getStoreRootForBackend(entry.backend));
+        if (entry.id === id && entryPath === nextPath) {
+            continue;
+        }
+        if (entry.id === id) {
+            throw new ContextStoreError(`Context store '${id}' is already registered at ${getStoreRootForBackend(entry.backend)}.`, 'context_store_id_conflict', {
+                target: 'context_store.id',
+                fix: 'Use the existing registration or choose a different context store id.',
+            });
+        }
+        if (entryPath === nextPath) {
+            throw new ContextStoreError(`Context store path is already registered as '${entry.id}'.`, 'context_store_path_conflict', {
+                target: 'context_store.root',
+                fix: `Use the existing '${entry.id}' registration or choose a different path.`,
+            });
+        }
+    }
+}
+function withRegisteredStore(registry, id, backend) {
+    assertNoRegisteredStoreConflict(registry, id, backend);
+    const stores = {
+        ...(registry?.stores ?? {}),
+        [id]: {
+            backend,
+        },
+    };
+    return {
+        version: 1,
+        stores: Object.fromEntries(Object.entries(stores).sort(([leftId], [rightId]) => leftId.localeCompare(rightId))),
+    };
+}
+async function ensureStoreMetadata(storeRoot, id, options) {
+    const metadata = await readOptionalContextStoreMetadataState(storeRoot);
+    if (!metadata) {
+        if (!options.writeIfMissing) {
+            throw new ContextStoreError(`Registered context store '${id}' is missing metadata at ${getContextStoreMetadataPath(storeRoot)}`, 'context_store_metadata_missing', {
+                target: 'context_store.metadata',
+                fix: `Create ${getContextStoreMetadataPath(storeRoot)} or rerun context-store register.`,
+            });
+        }
+        await writeContextStoreMetadataState(storeRoot, {
+            version: 1,
+            id,
+        });
+        return true;
+    }
+    if (metadata.id !== id) {
+        throw new ContextStoreError(`Context store metadata id '${metadata.id}' does not match registered id '${id}'`, 'context_store_metadata_id_mismatch', {
+            target: 'context_store.metadata',
+            fix: 'Repair the local registry or store metadata so the ids match.',
+        });
+    }
+    return false;
+}
+export async function commitContextStoreRegistration(input) {
+    const id = validateContextStoreId(input.id);
+    const backend = input.backend;
+    const storeRoot = getStoreRootForBackend(backend);
+    let metadataCreated = false;
+    try {
+        metadataCreated = await ensureStoreMetadata(storeRoot, id, {
+            writeIfMissing: input.writeMetadataIfMissing,
+        });
+        await updateContextStoreRegistryState((registry) => withRegisteredStore(registry, id, backend), { globalDataDir: input.globalDataDir });
+    }
+    catch (error) {
+        if (metadataCreated) {
+            await fs.rm(getContextStoreMetadataPath(storeRoot), { force: true });
+            await fs.rmdir(getContextStoreMetadataDir(storeRoot)).catch(() => undefined);
+        }
+        throw error;
+    }
+    return {
+        id,
+        storeRoot,
+        backend,
+        metadataCreated,
+    };
+}
+export async function registerContextStore(input) {
+    const id = validateContextStoreId(input.id);
+    const backend = await resolveGitContextStoreBackendConfig({
+        localPath: input.localPath,
+        ...(input.remote !== undefined ? { remote: input.remote } : {}),
+        ...(input.branch !== undefined ? { branch: input.branch } : {}),
+    }, input.cwd);
+    const storeRoot = getStoreRootForBackend(backend);
+    const committed = await commitContextStoreRegistration({
+        id,
+        backend,
+        writeMetadataIfMissing: true,
+        ...(input.globalDataDir ? { globalDataDir: input.globalDataDir } : {}),
+    });
+    return {
+        id: committed.id,
+        storeRoot: committed.storeRoot,
+        backend: committed.backend,
+    };
+}
+export async function listRegisteredContextStores(options = {}) {
+    const registry = await readContextStoreRegistryState(options);
+    if (!registry) {
+        return [];
+    }
+    return listContextStoreRegistryEntries(registry).map((entry) => ({
+        ...entry,
+        storeRoot: getStoreRootForBackend(entry.backend),
+    }));
+}
+export async function resolveRegisteredContextStore(input) {
+    const id = validateContextStoreId(input.id);
+    const registry = await readContextStoreRegistryState({
+        globalDataDir: input.globalDataDir,
+    });
+    if (!registry) {
+        throw new ContextStoreError('No context store registry found', 'no_context_store_registry', {
+            target: 'context_store.id',
+            fix: 'Register a context store before using --store, or pass --store-path <path>.',
+        });
+    }
+    const entry = registry.stores[id];
+    if (!entry) {
+        throw new ContextStoreError(`Unknown context store '${id}'`, 'context_store_not_found', {
+            target: 'context_store.id',
+            fix: 'Run pastelsdd context-store list to see registered stores.',
+        });
+    }
+    const backend = entry.backend;
+    const storeRoot = getStoreRootForBackend(backend);
+    await ensureStoreMetadata(storeRoot, id, { writeIfMissing: false });
+    return {
+        id,
+        storeRoot,
+        backend,
+    };
+}
+//# sourceMappingURL=registry.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/global-config.d.ts

@@ -0,0 +1,49 @@
+export declare const GLOBAL_CONFIG_DIR_NAME = "pastelsdd";
+export declare const GLOBAL_CONFIG_FILE_NAME = "config.json";
+export declare const GLOBAL_DATA_DIR_NAME = "pastelsdd";
+export type Profile = 'core' | 'custom';
+export type Delivery = 'both' | 'skills' | 'commands';
+export interface GlobalConfig {
+    featureFlags?: Record<string, boolean>;
+    profile?: Profile;
+    delivery?: Delivery;
+    workflows?: string[];
+}
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/pastelsdd/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/pastelsdd/
+ * - Windows fallback: %APPDATA%/pastelsdd/
+ */
+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/pastelsdd/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/pastelsdd/
+ * - Windows fallback: %LOCALAPPDATA%/pastelsdd/
+ */
+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