@codewalla_india/openspec 1.0.1

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

@@ -0,0 +1,58 @@
+import { type StoreBackendConfig, type StoreGitBackendConfig, type StorePathOptions, type StoreRegistryEntry, type StoreRegistryState } from './foundation.js';
+export interface RegisterStoreInput extends StorePathOptions {
+    id: string;
+    localPath: string;
+    remote?: string;
+    branch?: string;
+    cwd?: string;
+}
+export interface ResolveRegisteredStoreInput extends StorePathOptions {
+    id: string;
+}
+export interface GetRegisteredStoreInput extends ResolveRegisteredStoreInput {
+    expectedBackend?: StoreGitBackendConfig;
+}
+export interface UnregisterStoreInput extends StorePathOptions {
+    id: string;
+    expectedBackend?: StoreGitBackendConfig;
+    beforeCommit?: (entry: RegisteredStoreEntry) => Promise<void>;
+}
+export type ListRegisteredStoresOptions = StorePathOptions;
+export interface RegisteredStoreEntry extends StoreRegistryEntry {
+    storeRoot: string;
+}
+export interface ResolvedStore {
+    id: string;
+    storeRoot: string;
+    backend: StoreGitBackendConfig;
+}
+export interface StoreRegistrationCommit extends ResolvedStore {
+    metadataCreated: boolean;
+    registryUpdated: boolean;
+    alreadyRegistered: boolean;
+}
+export interface CommitStoreRegistrationInput extends StorePathOptions {
+    id: string;
+    backend: StoreGitBackendConfig;
+    writeMetadataIfMissing: boolean;
+}
+export declare function getStoreRootForBackend(backend: StoreBackendConfig): string;
+export declare function assertNoRegisteredStoreConflict(registry: StoreRegistryState | null, id: string, backend: StoreGitBackendConfig): void;
+export declare function commitStoreRegistration(input: CommitStoreRegistrationInput): Promise<StoreRegistrationCommit>;
+export declare function registerStore(input: RegisterStoreInput): Promise<ResolvedStore>;
+export interface RegistrySnapshot {
+    /** null = the registry is unreadable; [] = empty or absent. */
+    entries: StoreRegistryEntry[] | null;
+    unreadable: boolean;
+}
+/**
+ * One registry read serving every consumer in a command.
+ */
+export declare function readRegistrySnapshot(options?: {
+    globalDataDir?: string;
+}): Promise<RegistrySnapshot>;
+export declare function listRegisteredStores(options?: ListRegisteredStoresOptions): Promise<RegisteredStoreEntry[]>;
+export declare function getRegisteredStore(input: GetRegisteredStoreInput): Promise<RegisteredStoreEntry>;
+export declare function unregisterStoreRegistration(input: UnregisterStoreInput): Promise<RegisteredStoreEntry>;
+export declare function resolveRegisteredStore(input: ResolveRegisteredStoreInput): Promise<ResolvedStore>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/core/store/registry.js

@@ -0,0 +1,275 @@
+import * as fs from 'node:fs/promises';
+import { getStoreMetadataPath, getStoreMetadataDir, listStoreRegistryEntries, readStoreRegistryState, readOptionalStoreMetadataState, resolveGitStoreBackendConfig, updateStoreRegistryState, validateStoreId, writeStoreMetadataState, } from './foundation.js';
+import { StoreError } from './errors.js';
+import * as path from 'node:path';
+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 {
+        // Nonexistent (e.g. stale) paths still deserve a resolved compare;
+        // aligns with the operations.ts sibling fallback.
+        return path.resolve(targetPath);
+    }
+}
+export function assertNoRegisteredStoreConflict(registry, id, backend) {
+    const nextPath = normalizePathForComparison(getStoreRootForBackend(backend));
+    for (const entry of listStoreRegistryEntries(registry ?? { version: 1, stores: {} })) {
+        const entryPath = normalizePathForComparison(getStoreRootForBackend(entry.backend));
+        if (entry.id === id && entryPath === nextPath) {
+            continue;
+        }
+        if (entry.id === id) {
+            throw new StoreError(`Store '${id}' is already registered at ${getStoreRootForBackend(entry.backend)}. One checkout per store id is supported on this machine.`, 'store_id_conflict', {
+                target: 'store.id',
+                fix: `Use the existing registration, or run openspec store unregister ${id} first to switch this id to a different checkout.`,
+            });
+        }
+        if (entryPath === nextPath) {
+            throw new StoreError(`Store path is already registered as '${entry.id}'.`, 'store_path_conflict', {
+                target: '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))),
+    };
+}
+function getRegisteredStoreOrThrow(registry, id) {
+    const entry = registry?.stores[id];
+    if (!entry) {
+        throw new StoreError(`Unknown store '${id}'`, 'store_not_found', {
+            target: 'store.id',
+            fix: 'Run openspec store list to see registered stores.',
+        });
+    }
+    return {
+        id,
+        backend: entry.backend,
+    };
+}
+/** Same checkout: type, canonical path, and branch — remote excluded. */
+function sameCheckout(actual, expected) {
+    return (actual.type === expected.type &&
+        normalizePathForComparison(actual.local_path) ===
+            normalizePathForComparison(expected.local_path) &&
+        actual.branch === expected.branch);
+}
+function storeBackendsMatch(actual, expected) {
+    return sameCheckout(actual, expected) && actual.remote === expected.remote;
+}
+function assertExpectedRegisteredBackend(id, actual, expected) {
+    if (!expected || storeBackendsMatch(actual, expected))
+        return;
+    throw new StoreError(`Store '${id}' changed before cleanup completed.`, 'store_registry_changed', {
+        target: 'store.registry',
+        fix: 'Retry the cleanup command after reviewing the current store registration.',
+    });
+}
+function withoutRegisteredStore(registry, id, expectedBackend) {
+    const removed = getRegisteredStoreOrThrow(registry, id);
+    assertExpectedRegisteredBackend(id, removed.backend, expectedBackend);
+    const stores = { ...(registry?.stores ?? {}) };
+    delete stores[id];
+    return {
+        removed,
+        next: {
+            version: 1,
+            stores: Object.fromEntries(Object.entries(stores).sort(([leftId], [rightId]) => leftId.localeCompare(rightId))),
+        },
+    };
+}
+async function ensureStoreMetadata(storeRoot, id, options) {
+    const metadata = await readOptionalStoreMetadataState(storeRoot);
+    if (!metadata) {
+        if (!options.writeIfMissing) {
+            throw new StoreError(`Registered store '${id}' is missing metadata at ${getStoreMetadataPath(storeRoot)}`, 'store_metadata_missing', {
+                target: 'store.metadata',
+                fix: `Create ${getStoreMetadataPath(storeRoot)} or rerun "openspec store register <path>".`,
+            });
+        }
+        await writeStoreMetadataState(storeRoot, {
+            version: 1,
+            id,
+        });
+        return true;
+    }
+    if (metadata.id !== id) {
+        throw new StoreError(`Store metadata id '${metadata.id}' does not match registered id '${id}'`, 'store_metadata_id_mismatch', {
+            target: 'store.metadata',
+            fix: 'Repair the local registry or store metadata so the ids match.',
+        });
+    }
+    return false;
+}
+export async function commitStoreRegistration(input) {
+    const id = validateStoreId(input.id);
+    const backend = input.backend;
+    const storeRoot = getStoreRootForBackend(backend);
+    let metadataCreated = false;
+    let isRerun = false;
+    let registryUpdated = false;
+    try {
+        metadataCreated = await ensureStoreMetadata(storeRoot, id, {
+            writeIfMissing: input.writeMetadataIfMissing,
+        });
+        const registry = await readStoreRegistryState({
+            globalDataDir: input.globalDataDir,
+        });
+        const existing = registry?.stores[id];
+        const existingBackend = existing?.backend;
+        // Same checkout = a rerun for an already-registered store (the 1.3
+        // reporting contract), whether or not the observed remote changed;
+        // only a remote change needs the registry write (the refresh).
+        isRerun = existingBackend !== undefined && sameCheckout(existingBackend, backend);
+        const upToDate = isRerun && existingBackend !== undefined && storeBackendsMatch(existingBackend, backend);
+        if (!upToDate) {
+            await updateStoreRegistryState((registry) => withRegisteredStore(registry, id, backend), { globalDataDir: input.globalDataDir });
+            registryUpdated = true;
+        }
+    }
+    catch (error) {
+        if (metadataCreated) {
+            // A concurrent registration may have read our metadata as
+            // pre-existing and committed against it - never delete metadata a
+            // committed registry entry depends on.
+            const current = await readStoreRegistryState({
+                globalDataDir: input.globalDataDir,
+            }).catch(() => null);
+            if (!current?.stores[id]) {
+                await fs.rm(getStoreMetadataPath(storeRoot), { force: true });
+                await fs.rmdir(getStoreMetadataDir(storeRoot)).catch(() => undefined);
+            }
+        }
+        throw error;
+    }
+    return {
+        id,
+        storeRoot,
+        backend,
+        metadataCreated,
+        registryUpdated,
+        alreadyRegistered: isRerun,
+    };
+}
+export async function registerStore(input) {
+    const id = validateStoreId(input.id);
+    const backend = await resolveGitStoreBackendConfig({
+        localPath: input.localPath,
+        ...(input.remote !== undefined ? { remote: input.remote } : {}),
+        ...(input.branch !== undefined ? { branch: input.branch } : {}),
+    }, input.cwd);
+    const storeRoot = getStoreRootForBackend(backend);
+    const committed = await commitStoreRegistration({
+        id,
+        backend,
+        writeMetadataIfMissing: true,
+        ...(input.globalDataDir ? { globalDataDir: input.globalDataDir } : {}),
+    });
+    return {
+        id: committed.id,
+        storeRoot: committed.storeRoot,
+        backend: committed.backend,
+    };
+}
+/**
+ * One registry read serving every consumer in a command.
+ */
+export async function readRegistrySnapshot(options = {}) {
+    try {
+        const registry = await readStoreRegistryState(options);
+        return {
+            entries: registry ? listStoreRegistryEntries(registry) : [],
+            unreadable: false,
+        };
+    }
+    catch {
+        return { entries: null, unreadable: true };
+    }
+}
+export async function listRegisteredStores(options = {}) {
+    const registry = await readStoreRegistryState(options);
+    if (!registry) {
+        return [];
+    }
+    return listStoreRegistryEntries(registry).map((entry) => ({
+        ...entry,
+        storeRoot: getStoreRootForBackend(entry.backend),
+    }));
+}
+export async function getRegisteredStore(input) {
+    const id = validateStoreId(input.id);
+    const registry = await readStoreRegistryState({
+        globalDataDir: input.globalDataDir,
+    });
+    const entry = getRegisteredStoreOrThrow(registry, id);
+    assertExpectedRegisteredBackend(id, entry.backend, input.expectedBackend);
+    return {
+        ...entry,
+        storeRoot: getStoreRootForBackend(entry.backend),
+    };
+}
+export async function unregisterStoreRegistration(input) {
+    const id = validateStoreId(input.id);
+    let removed;
+    await updateStoreRegistryState(async (registry) => {
+        const result = withoutRegisteredStore(registry, id, input.expectedBackend);
+        const removedEntry = {
+            ...result.removed,
+            storeRoot: getStoreRootForBackend(result.removed.backend),
+        };
+        await input.beforeCommit?.(removedEntry);
+        removed = result.removed;
+        return result.next;
+    }, { globalDataDir: input.globalDataDir });
+    if (!removed) {
+        throw new StoreError(`Unknown store '${id}'`, 'store_not_found', {
+            target: 'store.id',
+            fix: 'Run openspec store list to see registered stores.',
+        });
+    }
+    return {
+        ...removed,
+        storeRoot: getStoreRootForBackend(removed.backend),
+    };
+}
+export async function resolveRegisteredStore(input) {
+    const id = validateStoreId(input.id);
+    const registry = await readStoreRegistryState({
+        globalDataDir: input.globalDataDir,
+    });
+    if (!registry) {
+        throw new StoreError('No store registry found', 'no_store_registry', {
+            target: 'store.id',
+            fix: 'Register a store with openspec store register <path>, then select it with --store <id>.',
+        });
+    }
+    const entry = getRegisteredStoreOrThrow(registry, id);
+    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/styles/palette.d.ts

@@ -0,0 +1,7 @@
+export declare const PALETTE: {
+    white: import("chalk").ChalkInstance;
+    lightGray: import("chalk").ChalkInstance;
+    midGray: import("chalk").ChalkInstance;
+    darkGray: import("chalk").ChalkInstance;
+};
+//# sourceMappingURL=palette.d.ts.map

package/dist/core/styles/palette.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export const PALETTE = {
+    white: chalk.hex('#f4f4f4'),
+    lightGray: chalk.hex('#c8c8c8'),
+    midGray: chalk.hex('#8a8a8a'),
+    darkGray: chalk.hex('#4a4a4a')
+};
+//# sourceMappingURL=palette.js.map

package/dist/core/templates/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Template exports for OpenSpec.
+ *
+ * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
+ * have been removed. The skill-based workflow uses skill-templates.ts directly.
+ */
+export * from './skill-templates.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/templates/index.js

@@ -0,0 +1,9 @@
+/**
+ * Template exports for OpenSpec.
+ *
+ * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
+ * have been removed. The skill-based workflow uses skill-templates.ts directly.
+ */
+// Re-export all skill templates and related types through the compatibility facade.
+export * from './skill-templates.js';
+//# sourceMappingURL=index.js.map

package/dist/core/templates/skill-templates.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Skill Templates
+ *
+ * Compatibility facade that re-exports split workflow template modules.
+ */
+export type { SkillTemplate, CommandTemplate } from './types.js';
+export { getExploreSkillTemplate, getOpsxExploreCommandTemplate } from './workflows/explore.js';
+export { getNewChangeSkillTemplate, getOpsxNewCommandTemplate } from './workflows/new-change.js';
+export { getContinueChangeSkillTemplate, getOpsxContinueCommandTemplate } from './workflows/continue-change.js';
+export { getApplyChangeSkillTemplate, getOpsxApplyCommandTemplate } from './workflows/apply-change.js';
+export { getFfChangeSkillTemplate, getOpsxFfCommandTemplate } from './workflows/ff-change.js';
+export { getSyncSpecsSkillTemplate, getOpsxSyncCommandTemplate } from './workflows/sync-specs.js';
+export { getArchiveChangeSkillTemplate, getOpsxArchiveCommandTemplate } from './workflows/archive-change.js';
+export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate } from './workflows/bulk-archive-change.js';
+export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
+export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
+export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getFeedbackSkillTemplate } from './workflows/feedback.js';
+//# sourceMappingURL=skill-templates.d.ts.map

package/dist/core/templates/skill-templates.js

@@ -0,0 +1,18 @@
+/**
+ * Agent Skill Templates
+ *
+ * Compatibility facade that re-exports split workflow template modules.
+ */
+export { getExploreSkillTemplate, getOpsxExploreCommandTemplate } from './workflows/explore.js';
+export { getNewChangeSkillTemplate, getOpsxNewCommandTemplate } from './workflows/new-change.js';
+export { getContinueChangeSkillTemplate, getOpsxContinueCommandTemplate } from './workflows/continue-change.js';
+export { getApplyChangeSkillTemplate, getOpsxApplyCommandTemplate } from './workflows/apply-change.js';
+export { getFfChangeSkillTemplate, getOpsxFfCommandTemplate } from './workflows/ff-change.js';
+export { getSyncSpecsSkillTemplate, getOpsxSyncCommandTemplate } from './workflows/sync-specs.js';
+export { getArchiveChangeSkillTemplate, getOpsxArchiveCommandTemplate } from './workflows/archive-change.js';
+export { getBulkArchiveChangeSkillTemplate, getOpsxBulkArchiveCommandTemplate } from './workflows/bulk-archive-change.js';
+export { getVerifyChangeSkillTemplate, getOpsxVerifyCommandTemplate } from './workflows/verify-change.js';
+export { getOnboardSkillTemplate, getOpsxOnboardCommandTemplate } from './workflows/onboard.js';
+export { getOpsxProposeSkillTemplate, getOpsxProposeCommandTemplate } from './workflows/propose.js';
+export { getFeedbackSkillTemplate } from './workflows/feedback.js';
+//# sourceMappingURL=skill-templates.js.map

package/dist/core/templates/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Core template types for skills and slash commands.
+ */
+export interface SkillTemplate {
+    name: string;
+    description: string;
+    instructions: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+}
+export interface CommandTemplate {
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    content: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/templates/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core template types for skills and slash commands.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/templates/workflows/apply-change.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Skill Template Workflow Modules
+ *
+ * This file is generated by splitting the legacy monolithic
+ * templates file into workflow-focused modules.
+ */
+import type { SkillTemplate, CommandTemplate } from '../types.js';
+export declare function getApplyChangeSkillTemplate(): SkillTemplate;
+export declare function getOpsxApplyCommandTemplate(): CommandTemplate;
+//# sourceMappingURL=apply-change.d.ts.map