@thiagodiogo/pastelsdd 1.0.0-beta.1

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

@@ -0,0 +1,197 @@
+import { getContextStoreMetadataPath, readOptionalContextStoreMetadataState, resolveGitContextStoreBackendConfig, validateContextStoreId, } from './foundation.js';
+import { ContextStoreError } from './errors.js';
+import { resolveRegisteredContextStore, } from './registry.js';
+export function createRegisteredContextStoreBinding(id) {
+    const validatedId = validateContextStoreId(id);
+    return {
+        id: validatedId,
+        selector: {
+            kind: 'registry',
+            id: validatedId,
+        },
+    };
+}
+export function createPathContextStoreBinding(input) {
+    const id = validateContextStoreId(input.id);
+    if (input.path.length === 0) {
+        throw new Error('Context store binding path must not be empty.');
+    }
+    return {
+        id,
+        selector: {
+            kind: 'path',
+            path: input.path,
+            observed_id: id,
+        },
+    };
+}
+export function normalizeContextStoreBinding(binding) {
+    const id = validateContextStoreId(binding.id);
+    if (binding.selector.kind === 'registry') {
+        return createRegisteredContextStoreBinding(binding.selector.id);
+    }
+    if (binding.selector.path.length === 0) {
+        throw new Error('Context store binding path must not be empty.');
+    }
+    return {
+        id,
+        selector: {
+            kind: 'path',
+            path: binding.selector.path,
+            ...(binding.selector.observed_id
+                ? { observed_id: validateContextStoreId(binding.selector.observed_id) }
+                : {}),
+        },
+    };
+}
+export function sameContextStoreBinding(left, right) {
+    const normalizedLeft = normalizeContextStoreBinding(left);
+    const normalizedRight = normalizeContextStoreBinding(right);
+    if (normalizedLeft.selector.kind !== normalizedRight.selector.kind) {
+        return false;
+    }
+    if (normalizedLeft.selector.kind === 'registry' &&
+        normalizedRight.selector.kind === 'registry') {
+        return normalizedLeft.selector.id === normalizedRight.selector.id;
+    }
+    if (normalizedLeft.selector.kind === 'path' &&
+        normalizedRight.selector.kind === 'path') {
+        return normalizedLeft.selector.path === normalizedRight.selector.path;
+    }
+    return false;
+}
+export function formatContextStoreBinding(binding) {
+    const normalized = normalizeContextStoreBinding(binding);
+    if (normalized.selector.kind === 'registry') {
+        return normalized.selector.id;
+    }
+    return `${normalized.id} via ${normalized.selector.path}`;
+}
+export function formatContextStoreBindingSelector(binding) {
+    const normalized = normalizeContextStoreBinding(binding);
+    return normalized.selector.kind === 'registry'
+        ? `--store ${normalized.selector.id}`
+        : `--store-path ${normalized.selector.path}`;
+}
+export function formatContextStoreSelector(selected) {
+    return selected.source === 'registry'
+        ? `--store ${selected.id}`
+        : `--store-path ${selected.root}`;
+}
+export function createContextStoreBindingFromSelected(selected) {
+    return selected.source === 'registry'
+        ? createRegisteredContextStoreBinding(selected.id)
+        : createPathContextStoreBinding({
+            id: selected.id,
+            path: selected.root,
+        });
+}
+function validateSelectorConflict(options, commandName) {
+    if (options.store !== undefined && options.storePath !== undefined) {
+        throw new ContextStoreError('Pass either --store <id> or --store-path <path>, not both.', 'context_store_selector_conflict', {
+            target: 'context_store',
+            fix: `pastelsdd ${commandName} --store <id>`,
+        });
+    }
+}
+export function requireContextStoreSelector(options, commandName) {
+    validateSelectorConflict(options, commandName);
+    if (options.store === undefined && options.storePath === undefined) {
+        throw new ContextStoreError('Pass --store <id> or --store-path <path>.', 'context_store_required', {
+            target: 'context_store',
+            fix: `pastelsdd ${commandName} --store <id>`,
+        });
+    }
+}
+export async function resolveSelectedContextStore(options, commandName, pathOptions = {}) {
+    requireContextStoreSelector(options, commandName);
+    if (options.store !== undefined) {
+        const resolved = await resolveRegisteredContextStore({
+            id: options.store,
+            globalDataDir: pathOptions.globalDataDir,
+        });
+        return {
+            id: resolved.id,
+            root: resolved.storeRoot,
+            source: 'registry',
+        };
+    }
+    const storePath = options.storePath ?? '';
+    let root;
+    try {
+        const backend = await resolveGitContextStoreBackendConfig({
+            localPath: storePath,
+        });
+        root = backend.local_path;
+    }
+    catch (error) {
+        throw new ContextStoreError(error instanceof Error ? error.message : String(error), 'invalid_context_store_path', {
+            target: 'context_store.path',
+            fix: 'Pass an existing context store root.',
+        });
+    }
+    let metadata;
+    try {
+        metadata = await readOptionalContextStoreMetadataState(root);
+    }
+    catch (error) {
+        throw new ContextStoreError(error instanceof Error ? error.message : String(error), 'invalid_context_store_metadata', {
+            target: 'context_store.metadata',
+            fix: `Fix ${getContextStoreMetadataPath(root)} before using this store.`,
+        });
+    }
+    if (!metadata) {
+        throw new ContextStoreError(`Context store metadata not found at ${getContextStoreMetadataPath(root)}`, 'context_store_metadata_not_found', {
+            target: 'context_store.metadata',
+            fix: 'Pass a context store root that contains .pastelsdd-store/store.yaml.',
+        });
+    }
+    return {
+        id: metadata.id,
+        root,
+        source: 'path',
+    };
+}
+export async function resolveContextStoreBinding(binding, options = {}) {
+    const normalized = normalizeContextStoreBinding(binding);
+    if (normalized.selector.kind === 'registry') {
+        const registered = await resolveRegisteredContextStore({
+            id: normalized.selector.id,
+            globalDataDir: options.globalDataDir,
+        });
+        return {
+            binding: normalized,
+            id: registered.id,
+            root: registered.storeRoot,
+            source: 'registry',
+            registered,
+            warnings: [],
+        };
+    }
+    const backend = await resolveGitContextStoreBackendConfig({
+        localPath: normalized.selector.path,
+    });
+    const root = backend.local_path;
+    const metadata = await readOptionalContextStoreMetadataState(root);
+    if (!metadata) {
+        throw new Error(`Context store metadata not found at ${getContextStoreMetadataPath(root)}`);
+    }
+    const warnings = [];
+    const observedId = normalized.selector.observed_id ?? normalized.id;
+    if (metadata.id !== observedId) {
+        warnings.push({
+            code: 'context_store_binding_id_changed',
+            message: `Context store at ${root} now reports id '${metadata.id}' instead of '${observedId}'.`,
+            target: 'metadata.id',
+            fix: `Review ${getContextStoreMetadataPath(root)} or re-open the workspace with the intended context store.`,
+        });
+    }
+    return {
+        binding: normalized,
+        id: metadata.id,
+        root,
+        source: 'path',
+        warnings,
+    };
+}
+//# sourceMappingURL=binding.js.map

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

@@ -0,0 +1,20 @@
+export type ContextStoreDiagnosticSeverity = 'error' | 'warning';
+export interface ContextStoreDiagnostic {
+    severity: ContextStoreDiagnosticSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+}
+export declare class ContextStoreError extends Error {
+    readonly diagnostic: ContextStoreDiagnostic;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+    });
+}
+export declare function makeContextStoreDiagnostic(severity: ContextStoreDiagnosticSeverity, code: string, message: string, options?: {
+    target?: string;
+    fix?: string;
+}): ContextStoreDiagnostic;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,22 @@
+export class ContextStoreError extends Error {
+    diagnostic;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.name = 'ContextStoreError';
+        this.diagnostic = {
+            severity: 'error',
+            code,
+            message,
+            ...options,
+        };
+    }
+}
+export function makeContextStoreDiagnostic(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        ...options,
+    };
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,54 @@
+export declare const CONTEXT_STORE_METADATA_DIR_NAME = ".pastelsdd-store";
+export declare const CONTEXT_STORE_METADATA_FILE_NAME = "store.yaml";
+export declare const CONTEXT_STORES_DIR_NAME = "context-stores";
+export declare const CONTEXT_STORE_REGISTRY_FILE_NAME = "registry.yaml";
+export interface ContextStorePathOptions {
+    globalDataDir?: string;
+}
+export interface ContextStoreGitBackendConfig {
+    type: 'git';
+    local_path: string;
+    remote?: string;
+    branch?: string;
+}
+export type ContextStoreBackendConfig = ContextStoreGitBackendConfig;
+export interface ContextStoreRegistryEntryState {
+    backend: ContextStoreBackendConfig;
+}
+export interface ContextStoreRegistryState {
+    version: 1;
+    stores: Record<string, ContextStoreRegistryEntryState>;
+}
+export interface ContextStoreRegistryEntry {
+    id: string;
+    backend: ContextStoreBackendConfig;
+}
+export interface ContextStoreMetadataState {
+    version: 1;
+    id: string;
+}
+export interface ResolveGitContextStoreBackendInput {
+    localPath: string;
+    remote?: string;
+    branch?: string;
+}
+export declare function getContextStoresDir(options?: ContextStorePathOptions): string;
+export declare function getContextStoreRegistryPath(options?: ContextStorePathOptions): string;
+export declare function getContextStoreMetadataDir(storeRoot: string): string;
+export declare function getContextStoreMetadataPath(storeRoot: string): string;
+export declare function validateContextStoreId(id: string): string;
+export declare function isValidContextStoreId(id: string): boolean;
+export declare function parseContextStoreRegistryState(content: string): ContextStoreRegistryState;
+export declare function parseContextStoreMetadataState(content: string): ContextStoreMetadataState;
+export declare function serializeContextStoreRegistryState(state: ContextStoreRegistryState): string;
+export declare function serializeContextStoreMetadataState(state: ContextStoreMetadataState): string;
+export declare function listContextStoreRegistryEntries(registry: ContextStoreRegistryState): ContextStoreRegistryEntry[];
+export declare function isContextStoreRoot(candidateRoot: string): Promise<boolean>;
+export declare function readContextStoreRegistryState(options?: ContextStorePathOptions): Promise<ContextStoreRegistryState | null>;
+export declare function writeContextStoreRegistryState(state: ContextStoreRegistryState, options?: ContextStorePathOptions): Promise<void>;
+export declare function updateContextStoreRegistryState(updater: (state: ContextStoreRegistryState | null) => ContextStoreRegistryState, options?: ContextStorePathOptions): Promise<ContextStoreRegistryState>;
+export declare function readContextStoreMetadataState(storeRoot: string): Promise<ContextStoreMetadataState>;
+export declare function readOptionalContextStoreMetadataState(storeRoot: string): Promise<ContextStoreMetadataState | null>;
+export declare function writeContextStoreMetadataState(storeRoot: string, state: ContextStoreMetadataState): Promise<void>;
+export declare function resolveGitContextStoreBackendConfig(input: ResolveGitContextStoreBackendInput, cwd?: string): Promise<ContextStoreGitBackendConfig>;
+//# sourceMappingURL=foundation.d.ts.map

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

@@ -0,0 +1,318 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { getGlobalDataDir } from '../global-config.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { ContextStoreError } from './errors.js';
+const fs = nodeFs.promises;
+export const CONTEXT_STORE_METADATA_DIR_NAME = '.pastelsdd-store';
+export const CONTEXT_STORE_METADATA_FILE_NAME = 'store.yaml';
+export const CONTEXT_STORES_DIR_NAME = 'context-stores';
+export const CONTEXT_STORE_REGISTRY_FILE_NAME = 'registry.yaml';
+function joinContextStorePath(basePath, ...segments) {
+    return FileSystemUtils.joinPath(basePath, ...segments);
+}
+export function getContextStoresDir(options = {}) {
+    return joinContextStorePath(options.globalDataDir ?? getGlobalDataDir(), CONTEXT_STORES_DIR_NAME);
+}
+export function getContextStoreRegistryPath(options = {}) {
+    return joinContextStorePath(getContextStoresDir(options), CONTEXT_STORE_REGISTRY_FILE_NAME);
+}
+export function getContextStoreMetadataDir(storeRoot) {
+    return joinContextStorePath(storeRoot, CONTEXT_STORE_METADATA_DIR_NAME);
+}
+export function getContextStoreMetadataPath(storeRoot) {
+    return joinContextStorePath(getContextStoreMetadataDir(storeRoot), CONTEXT_STORE_METADATA_FILE_NAME);
+}
+function validateFolderStyleName(name, label) {
+    if (name.length === 0) {
+        throw new Error(`${label} must not be empty`);
+    }
+    if (name === '.' || name === '..') {
+        throw new Error(`${label} must not be '${name}'`);
+    }
+    if (/[\\/]/u.test(name)) {
+        throw new Error(`${label} must not contain path separators`);
+    }
+    return name;
+}
+export function validateContextStoreId(id) {
+    try {
+        validateFolderStyleName(id, 'Context store id');
+    }
+    catch (error) {
+        throw new ContextStoreError(error instanceof Error ? error.message : String(error), 'invalid_context_store_id', {
+            target: 'context_store.id',
+            fix: 'Use kebab-case with lowercase letters, numbers, and single hyphen separators.',
+        });
+    }
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(id)) {
+        throw new ContextStoreError('Context store id must be kebab-case with lowercase letters, numbers, and single hyphen separators', 'invalid_context_store_id', {
+            target: 'context_store.id',
+            fix: 'Use kebab-case with lowercase letters, numbers, and single hyphen separators.',
+        });
+    }
+    return id;
+}
+export function isValidContextStoreId(id) {
+    try {
+        validateContextStoreId(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function pathIsFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function pathIsDirectory(dirPath) {
+    try {
+        return (await fs.stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFileNotFoundError(error) {
+    return isNodeErrorCode(error, 'ENOENT');
+}
+function isNodeErrorCode(error, code) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === code);
+}
+function normalizeExistingPathForStorage(existingPath) {
+    return FileSystemUtils.canonicalizeExistingPath(existingPath);
+}
+function nonEmptyOptionalString() {
+    return z.string().min(1).optional();
+}
+const GitBackendConfigSchema = z.object({
+    type: z.literal('git'),
+    local_path: z.string().min(1),
+    remote: nonEmptyOptionalString(),
+    branch: nonEmptyOptionalString(),
+}).strict();
+const RegistryEntrySchema = z.object({
+    backend: GitBackendConfigSchema,
+}).strict();
+const RegistryStateSchema = z.object({
+    version: z.literal(1),
+    stores: z.record(z.string(), RegistryEntrySchema),
+}).strict();
+const MetadataStateSchema = z.object({
+    version: z.literal(1),
+    id: z.string(),
+}).strict();
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+function contextStoreStateDiagnostic(label) {
+    if (label.includes('metadata')) {
+        return {
+            code: 'invalid_context_store_metadata',
+            target: 'context_store.metadata',
+            fix: 'Repair .pastelsdd-store/store.yaml.',
+        };
+    }
+    return {
+        code: 'invalid_context_store_registry',
+        target: 'context_store.registry',
+        fix: 'Repair or remove the context-store registry file.',
+    };
+}
+function invalidContextStoreStateError(label, message) {
+    const diagnostic = contextStoreStateDiagnostic(label);
+    return new ContextStoreError(`Invalid ${label}: ${message}`, diagnostic.code, {
+        target: diagnostic.target,
+        fix: diagnostic.fix,
+    });
+}
+function parseYamlObject(content, label) {
+    try {
+        return parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalidContextStoreStateError(label, message);
+    }
+}
+function assertValidContextStoreIds(ids, label) {
+    for (const id of ids) {
+        try {
+            validateContextStoreId(id);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw invalidContextStoreStateError(label, `'${id}': ${message}`);
+        }
+    }
+}
+export function parseContextStoreRegistryState(content) {
+    const raw = parseYamlObject(content, 'context store registry state');
+    const result = RegistryStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidContextStoreStateError('context store registry state', formatZodIssues(result.error));
+    }
+    assertValidContextStoreIds(Object.keys(result.data.stores), 'context store id');
+    return {
+        version: 1,
+        stores: result.data.stores,
+    };
+}
+export function parseContextStoreMetadataState(content) {
+    const raw = parseYamlObject(content, 'context store metadata state');
+    const result = MetadataStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidContextStoreStateError('context store metadata state', formatZodIssues(result.error));
+    }
+    validateContextStoreId(result.data.id);
+    return {
+        version: 1,
+        id: result.data.id,
+    };
+}
+export function serializeContextStoreRegistryState(state) {
+    const result = RegistryStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidContextStoreStateError('context store registry state', formatZodIssues(result.error));
+    }
+    assertValidContextStoreIds(Object.keys(result.data.stores), 'context store id');
+    return stringifyYaml({
+        version: 1,
+        stores: result.data.stores,
+    });
+}
+export function serializeContextStoreMetadataState(state) {
+    const result = MetadataStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidContextStoreStateError('context store metadata state', formatZodIssues(result.error));
+    }
+    validateContextStoreId(result.data.id);
+    return stringifyYaml({
+        version: 1,
+        id: result.data.id,
+    });
+}
+export function listContextStoreRegistryEntries(registry) {
+    return Object.entries(registry.stores)
+        .map(([id, store]) => ({ id, backend: store.backend }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function isContextStoreRoot(candidateRoot) {
+    return pathIsFile(getContextStoreMetadataPath(candidateRoot));
+}
+export async function readContextStoreRegistryState(options = {}) {
+    const registryPath = getContextStoreRegistryPath(options);
+    if (!(await pathIsFile(registryPath))) {
+        return null;
+    }
+    return parseContextStoreRegistryState(await fs.readFile(registryPath, 'utf-8'));
+}
+export async function writeContextStoreRegistryState(state, options = {}) {
+    await writeFileAtomically(getContextStoreRegistryPath(options), serializeContextStoreRegistryState(state));
+}
+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;
+    }
+}
+async function sleep(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function acquireContextStoreRegistryLock(options) {
+    const registryPath = getContextStoreRegistryPath(options);
+    const lockPath = `${registryPath}.lock`;
+    await FileSystemUtils.createDirectory(path.dirname(registryPath));
+    const deadline = Date.now() + 5000;
+    while (true) {
+        try {
+            return await fs.open(lockPath, 'wx');
+        }
+        catch (error) {
+            if (!isNodeErrorCode(error, 'EEXIST') || Date.now() >= deadline) {
+                throw new ContextStoreError('Context store registry is busy.', 'context_store_registry_busy', {
+                    target: 'context_store.registry',
+                    fix: 'Retry the command after the current registry update finishes.',
+                });
+            }
+            await sleep(25);
+        }
+    }
+}
+export async function updateContextStoreRegistryState(updater, options = {}) {
+    const registryPath = getContextStoreRegistryPath(options);
+    const lockPath = `${registryPath}.lock`;
+    const lock = await acquireContextStoreRegistryLock(options);
+    try {
+        const next = updater(await readContextStoreRegistryState(options));
+        await writeContextStoreRegistryState(next, options);
+        return next;
+    }
+    finally {
+        await lock.close().catch(() => undefined);
+        await fs.rm(lockPath, { force: true }).catch(() => undefined);
+    }
+}
+export async function readContextStoreMetadataState(storeRoot) {
+    return parseContextStoreMetadataState(await fs.readFile(getContextStoreMetadataPath(storeRoot), 'utf-8'));
+}
+export async function readOptionalContextStoreMetadataState(storeRoot) {
+    try {
+        return await readContextStoreMetadataState(storeRoot);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeContextStoreMetadataState(storeRoot, state) {
+    await FileSystemUtils.writeFile(getContextStoreMetadataPath(storeRoot), serializeContextStoreMetadataState(state));
+}
+export async function resolveGitContextStoreBackendConfig(input, cwd = process.cwd()) {
+    if (input.localPath.length === 0) {
+        throw new Error('Context store local path must not be empty.');
+    }
+    const resolvedPath = path.isAbsolute(input.localPath)
+        ? path.resolve(input.localPath)
+        : path.resolve(cwd, input.localPath);
+    if (!(await pathIsDirectory(resolvedPath))) {
+        throw new Error(`Context store local path does not exist: ${input.localPath}`);
+    }
+    if (input.remote !== undefined && input.remote.length === 0) {
+        throw new Error('Context store remote must not be empty when provided.');
+    }
+    if (input.branch !== undefined && input.branch.length === 0) {
+        throw new Error('Context store branch must not be empty when provided.');
+    }
+    return {
+        type: 'git',
+        local_path: normalizeExistingPathForStorage(resolvedPath),
+        ...(input.remote ? { remote: input.remote } : {}),
+        ...(input.branch ? { branch: input.branch } : {}),
+    };
+}
+//# sourceMappingURL=foundation.js.map

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

@@ -0,0 +1,6 @@
+export * from './foundation.js';
+export * from './errors.js';
+export * from './registry.js';
+export * from './binding.js';
+export * from './operations.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './foundation.js';
+export * from './errors.js';
+export * from './registry.js';
+export * from './binding.js';
+export * from './operations.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,62 @@
+import { type ContextStoreGitBackendConfig, type ContextStoreRegistryState } from './foundation.js';
+import { type ContextStoreDiagnostic } from './errors.js';
+type PathKind = 'missing' | 'directory' | 'file' | 'other';
+export interface ContextStoreInfo {
+    id: string;
+    root: string;
+    metadataPath?: string;
+}
+export interface ContextStoreMutationResult {
+    store: ContextStoreInfo;
+    registryCommit: {
+        path: string;
+    };
+    git: {
+        isRepository: boolean;
+        initialized: boolean;
+    };
+    createdArtifacts: string[];
+}
+export interface ContextStoreListResult {
+    stores: ContextStoreInfo[];
+}
+export interface ContextStoreDoctorResult {
+    stores: ContextStoreInspection[];
+    diagnostics: ContextStoreDiagnostic[];
+}
+export interface ContextStoreInspection extends ContextStoreInfo {
+    metadata: {
+        present: boolean | null;
+        valid: boolean | null;
+        id?: string;
+    };
+    git: {
+        isRepository: boolean | null;
+    };
+    diagnostics: ContextStoreDiagnostic[];
+}
+export interface SetupContextStoreInput {
+    id?: string;
+    path?: string;
+    initGit?: boolean;
+}
+export interface RegisterExistingContextStoreInput {
+    path?: string;
+    id?: string;
+}
+export interface PreparedContextStoreSetup {
+    id: string;
+    root: string;
+    rootKind: Extract<PathKind, 'missing' | 'directory'>;
+    backend?: ContextStoreGitBackendConfig;
+    registry: ContextStoreRegistryState | null;
+}
+export declare function prepareContextStoreSetup(input: Pick<SetupContextStoreInput, 'id' | 'path'>): Promise<PreparedContextStoreSetup>;
+export declare function setupPreparedContextStore(prepared: PreparedContextStoreSetup, input?: Pick<SetupContextStoreInput, 'initGit'>): Promise<ContextStoreMutationResult>;
+export declare function setupContextStore(input: SetupContextStoreInput): Promise<ContextStoreMutationResult>;
+export declare function registerExistingContextStore(input: RegisterExistingContextStoreInput): Promise<ContextStoreMutationResult>;
+export declare function listContextStores(): Promise<ContextStoreListResult>;
+export declare function doctorContextStores(id?: string): Promise<ContextStoreDoctorResult>;
+export declare function normalizeContextStorePathForComparison(targetPath: string): string;
+export {};
+//# sourceMappingURL=operations.d.ts.map