@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/store/in-memory-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { z } from 'zod';
+import type { StateStore } from './state-store.js';
+export declare class InMemoryAdapter<T> implements StateStore<T> {
+    private readonly schema;
+    private readonly defaultFactory;
+    private state;
+    constructor(schema: z.ZodType<T>, defaultFactory: () => T);
+    load(): Promise<T>;
+    save(state: T): Promise<void>;
+    exists(): Promise<boolean>;
+}
+//# sourceMappingURL=in-memory-adapter.d.ts.map

package/dist/core/sdd/store/in-memory-adapter.js

@@ -0,0 +1,27 @@
+export class InMemoryAdapter {
+    schema;
+    defaultFactory;
+    state = undefined;
+    constructor(schema, defaultFactory) {
+        this.schema = schema;
+        this.defaultFactory = defaultFactory;
+    }
+    async load() {
+        if (this.state === undefined) {
+            return this.defaultFactory();
+        }
+        // Return a deep copy (simulating serialization/deserialization boundary)
+        // to prevent accidental mutation of the store by reference.
+        return structuredClone(this.state);
+    }
+    async save(state) {
+        // We parse the state through Zod to ensure test logic correctly validates business rules.
+        const validState = this.schema.parse(state);
+        // Store a deep copy to prevent mutation by reference after saving.
+        this.state = structuredClone(validState);
+    }
+    async exists() {
+        return this.state !== undefined;
+    }
+}
+//# sourceMappingURL=in-memory-adapter.js.map

package/dist/core/sdd/store/index.d.ts

@@ -0,0 +1,5 @@
+export * from './state-store.js';
+export * from './yaml-file-adapter.js';
+export * from './in-memory-adapter.js';
+export * from './sdd-stores.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/sdd/store/index.js

@@ -0,0 +1,5 @@
+export * from './state-store.js';
+export * from './yaml-file-adapter.js';
+export * from './in-memory-adapter.js';
+export * from './sdd-stores.js';
+//# sourceMappingURL=index.js.map

package/dist/core/sdd/store/sdd-stores.d.ts

@@ -0,0 +1,25 @@
+import type { SddPaths } from '../state.js';
+import type { StateStore } from './state-store.js';
+import { type BacklogState, type DiscoveryIndexState, type FinalizeQueueState, type FrontendDecisionsState, type FrontendGapsState, type FrontendMapState, type IntegrationContractsState, type RepoMapState, type SourceIndexState, type SkillCatalogState, type SkillRoutingState, type ServiceCatalogState, type TechStackState, type TechDebtState, type UnblockEventsState, type TransitionLogState, type ArchitectureState } from '../types.js';
+export interface SddStores {
+    discoveryIndex: StateStore<DiscoveryIndexState>;
+    backlog: StateStore<BacklogState>;
+    techDebt: StateStore<TechDebtState>;
+    finalizeQueue: StateStore<FinalizeQueueState>;
+    skillCatalog: StateStore<SkillCatalogState>;
+    unblockEvents: StateStore<UnblockEventsState>;
+    transitionLog: StateStore<TransitionLogState>;
+    frontendGaps: StateStore<FrontendGapsState>;
+    frontendMap: StateStore<FrontendMapState>;
+    architecture: StateStore<ArchitectureState>;
+    serviceCatalog: StateStore<ServiceCatalogState>;
+    techStack: StateStore<TechStackState>;
+    integrationContracts: StateStore<IntegrationContractsState>;
+    frontendDecisions: StateStore<FrontendDecisionsState>;
+    repoMap: StateStore<RepoMapState>;
+    sourceIndex: StateStore<SourceIndexState>;
+    skillRouting: StateStore<SkillRoutingState>;
+}
+export declare function createSddStores(paths: SddPaths): SddStores;
+export declare function createInMemorySddStores(): SddStores;
+//# sourceMappingURL=sdd-stores.d.ts.map

package/dist/core/sdd/store/sdd-stores.js

@@ -0,0 +1,59 @@
+import { YamlFileAdapter } from './yaml-file-adapter.js';
+import { InMemoryAdapter } from './in-memory-adapter.js';
+import { BacklogStateSchema, DiscoveryIndexStateSchema, FinalizeQueueStateSchema, FrontendDecisionsStateSchema, FrontendGapsStateSchema, FrontendMapStateSchema, IntegrationContractsStateSchema, RepoMapStateSchema, SourceIndexStateSchema, SkillCatalogStateSchema, SkillRoutingStateSchema, ServiceCatalogStateSchema, TechStackStateSchema, TechDebtStateSchema, UnblockEventsStateSchema, TransitionLogStateSchema, ArchitectureStateSchema, } from '../types.js';
+export function createSddStores(paths) {
+    const { stateFiles } = paths;
+    return {
+        discoveryIndex: new YamlFileAdapter(stateFiles.discoveryIndex, DiscoveryIndexStateSchema, () => ({ version: 1, counters: { INS: 0, DEB: 0, RAD: 0, EPIC: 0, FEAT: 0, FGAP: 0, TD: 0 }, records: [] })),
+        backlog: new YamlFileAdapter(stateFiles.backlog, BacklogStateSchema, () => ({ version: 1, items: [] })),
+        techDebt: new YamlFileAdapter(stateFiles.techDebt, TechDebtStateSchema, () => ({ version: 1, items: [] })),
+        finalizeQueue: new YamlFileAdapter(stateFiles.finalizeQueue, FinalizeQueueStateSchema, () => ({ version: 1, items: [] })),
+        skillCatalog: new YamlFileAdapter(stateFiles.skillCatalog, SkillCatalogStateSchema, () => ({ version: 1, skills: [], bundles: [] })),
+        unblockEvents: new YamlFileAdapter(stateFiles.unblockEvents, UnblockEventsStateSchema, () => ({ version: 1, events: [] })),
+        transitionLog: new YamlFileAdapter(stateFiles.transitionLog, TransitionLogStateSchema, () => ({ version: 1, events: [] })),
+        frontendGaps: new YamlFileAdapter(stateFiles.frontendGaps, FrontendGapsStateSchema, () => ({ version: 1, items: [] })),
+        frontendMap: new YamlFileAdapter(stateFiles.frontendMap, FrontendMapStateSchema, () => ({ version: 1, routes: [] })),
+        architecture: new YamlFileAdapter(stateFiles.architecture, ArchitectureStateSchema, () => ({ version: 1, nodes: [] })),
+        serviceCatalog: new YamlFileAdapter(stateFiles.serviceCatalog, ServiceCatalogStateSchema, () => ({ version: 1, services: [] })),
+        techStack: new YamlFileAdapter(stateFiles.techStack, TechStackStateSchema, () => ({ version: 1, items: [] })),
+        integrationContracts: new YamlFileAdapter(stateFiles.integrationContracts, IntegrationContractsStateSchema, () => ({ version: 1, contracts: [] })),
+        frontendDecisions: new YamlFileAdapter(stateFiles.frontendDecisions, FrontendDecisionsStateSchema, () => ({ version: 1, items: [] })),
+        repoMap: new YamlFileAdapter(stateFiles.repoMap, RepoMapStateSchema, () => ({ version: 1, items: [] })),
+        sourceIndex: new YamlFileAdapter(stateFiles.sourceIndex, SourceIndexStateSchema, () => ({
+            version: 1,
+            sources: [],
+            version_events: [],
+            jurisdiction_profiles: [],
+            control_catalog: [],
+        })),
+        skillRouting: new YamlFileAdapter(stateFiles.skillRouting, SkillRoutingStateSchema, () => ({ version: 1, default_skills: [], routes: [] })),
+    };
+}
+export function createInMemorySddStores() {
+    return {
+        discoveryIndex: new InMemoryAdapter(DiscoveryIndexStateSchema, () => ({ version: 1, counters: { INS: 0, DEB: 0, RAD: 0, EPIC: 0, FEAT: 0, FGAP: 0, TD: 0 }, records: [] })),
+        backlog: new InMemoryAdapter(BacklogStateSchema, () => ({ version: 1, items: [] })),
+        techDebt: new InMemoryAdapter(TechDebtStateSchema, () => ({ version: 1, items: [] })),
+        finalizeQueue: new InMemoryAdapter(FinalizeQueueStateSchema, () => ({ version: 1, items: [] })),
+        skillCatalog: new InMemoryAdapter(SkillCatalogStateSchema, () => ({ version: 1, skills: [], bundles: [] })),
+        unblockEvents: new InMemoryAdapter(UnblockEventsStateSchema, () => ({ version: 1, events: [] })),
+        transitionLog: new InMemoryAdapter(TransitionLogStateSchema, () => ({ version: 1, events: [] })),
+        frontendGaps: new InMemoryAdapter(FrontendGapsStateSchema, () => ({ version: 1, items: [] })),
+        frontendMap: new InMemoryAdapter(FrontendMapStateSchema, () => ({ version: 1, routes: [] })),
+        architecture: new InMemoryAdapter(ArchitectureStateSchema, () => ({ version: 1, nodes: [] })),
+        serviceCatalog: new InMemoryAdapter(ServiceCatalogStateSchema, () => ({ version: 1, services: [] })),
+        techStack: new InMemoryAdapter(TechStackStateSchema, () => ({ version: 1, items: [] })),
+        integrationContracts: new InMemoryAdapter(IntegrationContractsStateSchema, () => ({ version: 1, contracts: [] })),
+        frontendDecisions: new InMemoryAdapter(FrontendDecisionsStateSchema, () => ({ version: 1, items: [] })),
+        repoMap: new InMemoryAdapter(RepoMapStateSchema, () => ({ version: 1, items: [] })),
+        sourceIndex: new InMemoryAdapter(SourceIndexStateSchema, () => ({
+            version: 1,
+            sources: [],
+            version_events: [],
+            jurisdiction_profiles: [],
+            control_catalog: [],
+        })),
+        skillRouting: new InMemoryAdapter(SkillRoutingStateSchema, () => ({ version: 1, default_skills: [], routes: [] })),
+    };
+}
+//# sourceMappingURL=sdd-stores.js.map

package/dist/core/sdd/store/state-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generic interface for accessing SDD state.
+ * This abstracts away the underlying storage mechanism (YAML files, in-memory, SQLite, etc.)
+ * from the domain services.
+ */
+export interface StateStore<T> {
+    /**
+     * Loads the current state from storage.
+     * If the state does not exist, it should return a default empty state
+     * according to the store's configuration.
+     *
+     * @returns A promise that resolves to the parsed and validated state.
+     */
+    load(): Promise<T>;
+    /**
+     * Saves the state to storage.
+     * In a test environment or strict mode, this method should validate the state
+     * against its schema before persisting it.
+     *
+     * @param state The state object to persist.
+     */
+    save(state: T): Promise<void>;
+    /**
+     * Checks if the state currently exists in storage.
+     * Note: This checks for persistence presence (e.g., if the file exists),
+     * it does not necessarily mean the state is populated or valid.
+     *
+     * @returns A promise resolving to true if the state exists in storage.
+     */
+    exists(): Promise<boolean>;
+}
+//# sourceMappingURL=state-store.d.ts.map

package/dist/core/sdd/store/state-store.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-store.js.map

package/dist/core/sdd/store/yaml-file-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { z } from 'zod';
+import type { StateStore } from './state-store.js';
+export declare class YamlFileAdapter<T> implements StateStore<T> {
+    private readonly filePath;
+    private readonly schema;
+    private readonly defaultFactory;
+    constructor(filePath: string, schema: z.ZodType<T>, defaultFactory: () => T);
+    load(): Promise<T>;
+    save(state: T): Promise<void>;
+    exists(): Promise<boolean>;
+}
+//# sourceMappingURL=yaml-file-adapter.d.ts.map

package/dist/core/sdd/store/yaml-file-adapter.js

@@ -0,0 +1,43 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+export class YamlFileAdapter {
+    filePath;
+    schema;
+    defaultFactory;
+    constructor(filePath, schema, defaultFactory) {
+        this.filePath = filePath;
+        this.schema = schema;
+        this.defaultFactory = defaultFactory;
+    }
+    async load() {
+        try {
+            const content = await fs.readFile(this.filePath, 'utf-8');
+            const parsed = parseYaml(content);
+            return this.schema.parse(parsed);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return this.defaultFactory();
+            }
+            throw new Error(`Failed to load or validate state from ${this.filePath}: ${error.message}`);
+        }
+    }
+    async save(state) {
+        // We parse the state through Zod to ensure domain logic doesn't write invalid schema payloads to disk.
+        const validState = this.schema.parse(state);
+        // Ensure parent directory exists before writing
+        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+        await fs.writeFile(this.filePath, stringifyYaml(validState), 'utf-8');
+    }
+    async exists() {
+        try {
+            await fs.access(this.filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=yaml-file-adapter.js.map