gmc-openspec 1.0.0 → 1.4.1

package/dist/core/completions/shared-flags.d.ts

@@ -0,0 +1,12 @@
+import type { FlagDefinition } from './types.js';
+/**
+ * Common flags used across multiple commands.
+ */
+export declare const COMMON_FLAGS: {
+    readonly json: FlagDefinition;
+    readonly jsonValidation: FlagDefinition;
+    readonly strict: FlagDefinition;
+    readonly noInteractive: FlagDefinition;
+    readonly type: FlagDefinition;
+};
+//# sourceMappingURL=shared-flags.d.ts.map

package/dist/core/completions/shared-flags.js

@@ -0,0 +1,28 @@
+/**
+ * Common flags used across multiple commands.
+ */
+export const COMMON_FLAGS = {
+    json: {
+        name: 'json',
+        description: 'Output as JSON',
+    },
+    jsonValidation: {
+        name: 'json',
+        description: 'Output validation results as JSON',
+    },
+    strict: {
+        name: 'strict',
+        description: 'Enable strict validation mode',
+    },
+    noInteractive: {
+        name: 'no-interactive',
+        description: 'Disable interactive prompts',
+    },
+    type: {
+        name: 'type',
+        description: 'Specify item type when ambiguous',
+        takesValue: true,
+        values: ['change', 'spec'],
+    },
+};
+//# sourceMappingURL=shared-flags.js.map

package/dist/core/config.js

@@ -25,10 +25,11 @@ export const AI_TOOLS = [
     { 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: 'Lingma', value: 'lingma', available: true, successLabel: 'Lingma', skillsDir: '.lingma' },
     { 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' },

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

@@ -0,0 +1,53 @@
+import { type ContextStorePathOptions } from './foundation.js';
+import { type ResolvedContextStore } from './registry.js';
+export type ContextStoreSelector = {
+    kind: 'registry';
+    id: string;
+} | {
+    kind: 'path';
+    path: string;
+    observed_id?: string;
+};
+export type ContextStoreSelectorSource = 'registry' | 'path';
+export interface ContextStoreSelectorOptions {
+    store?: string;
+    storePath?: string;
+}
+export interface SelectedContextStore {
+    id: string;
+    root: string;
+    source: ContextStoreSelectorSource;
+}
+export interface ContextStoreBinding {
+    id: string;
+    selector: ContextStoreSelector;
+}
+export interface ContextStoreBindingWarning {
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+}
+export interface ResolvedContextStoreBinding {
+    binding: ContextStoreBinding;
+    id: string;
+    root: string;
+    source: 'registry' | 'path';
+    registered?: ResolvedContextStore;
+    warnings: ContextStoreBindingWarning[];
+}
+export declare function createRegisteredContextStoreBinding(id: string): ContextStoreBinding;
+export declare function createPathContextStoreBinding(input: {
+    id: string;
+    path: string;
+}): ContextStoreBinding;
+export declare function normalizeContextStoreBinding(binding: ContextStoreBinding): ContextStoreBinding;
+export declare function sameContextStoreBinding(left: ContextStoreBinding, right: ContextStoreBinding): boolean;
+export declare function formatContextStoreBinding(binding: ContextStoreBinding): string;
+export declare function formatContextStoreBindingSelector(binding: ContextStoreBinding): string;
+export declare function formatContextStoreSelector(selected: SelectedContextStore): string;
+export declare function createContextStoreBindingFromSelected(selected: SelectedContextStore): ContextStoreBinding;
+export declare function requireContextStoreSelector(options: ContextStoreSelectorOptions, commandName: string): void;
+export declare function resolveSelectedContextStore(options: ContextStoreSelectorOptions, commandName: string, pathOptions?: ContextStorePathOptions): Promise<SelectedContextStore>;
+export declare function resolveContextStoreBinding(binding: ContextStoreBinding, options?: ContextStorePathOptions): Promise<ResolvedContextStoreBinding>;
+//# sourceMappingURL=binding.d.ts.map

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: `openspec ${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: `openspec ${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 .openspec-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,55 @@
+export declare const CONTEXT_STORE_METADATA_DIR_NAME = ".openspec-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 getDefaultContextStoreRoot(id: string, 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 | Promise<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