@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/backlog-projection.js

@@ -0,0 +1,89 @@
+import { backlogProjectionPlanSchema, buildBacklogProjectionItem, createBacklogProviderContract, } from './backlog-provider-contract.js';
+const AZURE_DEVOPS_EXTERNAL_TYPES = {
+    epic: 'Epic',
+    feature: 'User Story',
+};
+export function builtInAzureDevOpsBacklogContract() {
+    return createBacklogProviderContract({
+        schema_version: 1,
+        provider: 'azure-devops',
+        adapter_id: 'azure-devops',
+        label: 'Azure DevOps Boards',
+        status: 'experimental',
+        auth: {
+            mode: 'pat',
+            required_env: ['AZURE_DEVOPS_EXT_PAT'],
+            secret_fields: ['AZURE_DEVOPS_EXT_PAT'],
+        },
+        capabilities: [
+            {
+                operation: 'create',
+                entity_kinds: ['epic', 'feature'],
+                dry_run: true,
+                apply: false,
+                idempotent: true,
+                required_fields: ['System.Title', 'System.State', 'Custom.CodeSDDRef'],
+            },
+            {
+                operation: 'link',
+                entity_kinds: ['epic', 'feature'],
+                dry_run: true,
+                apply: false,
+                idempotent: true,
+            },
+        ],
+        mapping: {
+            external_project_field: 'System.TeamProject',
+            external_id_field: 'System.Id',
+            external_url_field: 'System.Url',
+            canonical_ref_field: 'Custom.CodeSDDRef',
+            parent_ref_field: 'Custom.CodeSDDParentRef',
+            entity_type_field: 'Custom.CodeSDDEntityType',
+            title_field: 'System.Title',
+            status_field: 'System.State',
+        },
+        canonical_state_boundary: {
+            source_of_truth: 'codesdd',
+            state_paths: ['.sdd/state/*.yaml'],
+            external_state_authoritative: false,
+            hidden_state_allowed: false,
+        },
+        governance: {
+            owner: 'platform-architecture',
+            sync_requires_dry_run: true,
+            mutation_requires_approval: true,
+            audit_event: 'codesdd.backlog.projection',
+        },
+    });
+}
+export function buildAzureDevOpsBacklogProjectionPlan(input) {
+    const contract = input.contract
+        ? createBacklogProviderContract(input.contract)
+        : builtInAzureDevOpsBacklogContract();
+    if (contract.provider !== 'azure-devops') {
+        throw new Error(`Azure DevOps projection planner requires provider azure-devops, received ${contract.provider}.`);
+    }
+    const projectedItems = input.items.map((item) => {
+        const externalType = AZURE_DEVOPS_EXTERNAL_TYPES[item.kind];
+        if (!externalType) {
+            throw new Error(`Azure DevOps projection planner supports only epic and feature items, received ${item.kind}.`);
+        }
+        return buildBacklogProjectionItem({
+            contract,
+            item,
+            external_type: externalType,
+            operation: 'create',
+        });
+    });
+    return backlogProjectionPlanSchema.parse({
+        schema_version: 1,
+        created_at: input.created_at ?? new Date().toISOString(),
+        provider: 'azure-devops',
+        mode: 'dry-run',
+        direction: 'push',
+        source_of_truth: 'codesdd',
+        items: projectedItems,
+        warnings: [],
+    });
+}
+//# sourceMappingURL=backlog-projection.js.map

package/dist/core/sdd/backlog-provider-contract.d.ts

@@ -0,0 +1,252 @@
+import { z } from 'zod';
+export declare const backlogProviderIdSchema: z.ZodEnum<{
+    generic: "generic";
+    "azure-devops": "azure-devops";
+    jira: "jira";
+    trello: "trello";
+    confluence: "confluence";
+    asana: "asana";
+}>;
+export declare const backlogEntityKindSchema: z.ZodEnum<{
+    epic: "epic";
+    feature: "feature";
+    insight: "insight";
+    debate: "debate";
+    task: "task";
+}>;
+export declare const backlogProviderOperationSchema: z.ZodEnum<{
+    link: "link";
+    update: "update";
+    create: "create";
+    query: "query";
+}>;
+export declare const backlogProjectionModeSchema: z.ZodEnum<{
+    apply: "apply";
+    "dry-run": "dry-run";
+}>;
+export declare const backlogProjectionDirectionSchema: z.ZodEnum<{
+    push: "push";
+    pull: "pull";
+    bidirectional: "bidirectional";
+}>;
+export declare const backlogAuthModeSchema: z.ZodEnum<{
+    none: "none";
+    pat: "pat";
+    oauth: "oauth";
+    "managed-identity": "managed-identity";
+    "app-installation": "app-installation";
+}>;
+export declare const backlogProviderCapabilitySchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        link: "link";
+        update: "update";
+        create: "create";
+        query: "query";
+    }>;
+    entity_kinds: z.ZodArray<z.ZodEnum<{
+        epic: "epic";
+        feature: "feature";
+        insight: "insight";
+        debate: "debate";
+        task: "task";
+    }>>;
+    dry_run: z.ZodDefault<z.ZodBoolean>;
+    apply: z.ZodDefault<z.ZodBoolean>;
+    idempotent: z.ZodDefault<z.ZodBoolean>;
+    required_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const backlogProviderContractSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    provider: z.ZodEnum<{
+        generic: "generic";
+        "azure-devops": "azure-devops";
+        jira: "jira";
+        trello: "trello";
+        confluence: "confluence";
+        asana: "asana";
+    }>;
+    adapter_id: z.ZodString;
+    label: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        experimental: "experimental";
+        disabled: "disabled";
+        active: "active";
+    }>>;
+    auth: z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            pat: "pat";
+            oauth: "oauth";
+            "managed-identity": "managed-identity";
+            "app-installation": "app-installation";
+        }>;
+        required_env: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        secret_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        operation: z.ZodEnum<{
+            link: "link";
+            update: "update";
+            create: "create";
+            query: "query";
+        }>;
+        entity_kinds: z.ZodArray<z.ZodEnum<{
+            epic: "epic";
+            feature: "feature";
+            insight: "insight";
+            debate: "debate";
+            task: "task";
+        }>>;
+        dry_run: z.ZodDefault<z.ZodBoolean>;
+        apply: z.ZodDefault<z.ZodBoolean>;
+        idempotent: z.ZodDefault<z.ZodBoolean>;
+        required_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    mapping: z.ZodObject<{
+        external_project_field: z.ZodOptional<z.ZodString>;
+        external_id_field: z.ZodString;
+        external_url_field: z.ZodOptional<z.ZodString>;
+        canonical_ref_field: z.ZodString;
+        parent_ref_field: z.ZodOptional<z.ZodString>;
+        entity_type_field: z.ZodString;
+        title_field: z.ZodString;
+        status_field: z.ZodString;
+    }, z.core.$strip>;
+    canonical_state_boundary: z.ZodObject<{
+        source_of_truth: z.ZodLiteral<"codesdd">;
+        state_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        external_state_authoritative: z.ZodLiteral<false>;
+        hidden_state_allowed: z.ZodLiteral<false>;
+    }, z.core.$strip>;
+    governance: z.ZodObject<{
+        owner: z.ZodString;
+        sync_requires_dry_run: z.ZodDefault<z.ZodBoolean>;
+        mutation_requires_approval: z.ZodDefault<z.ZodBoolean>;
+        audit_event: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const canonicalBacklogItemSchema: z.ZodObject<{
+    ref: z.ZodString;
+    kind: z.ZodEnum<{
+        epic: "epic";
+        feature: "feature";
+        insight: "insight";
+        debate: "debate";
+    }>;
+    title: z.ZodString;
+    status: z.ZodString;
+    parent_ref: z.ZodOptional<z.ZodString>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const backlogProjectionItemSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    provider: z.ZodEnum<{
+        generic: "generic";
+        "azure-devops": "azure-devops";
+        jira: "jira";
+        trello: "trello";
+        confluence: "confluence";
+        asana: "asana";
+    }>;
+    canonical_ref: z.ZodString;
+    entity_kind: z.ZodEnum<{
+        epic: "epic";
+        feature: "feature";
+        insight: "insight";
+        debate: "debate";
+        task: "task";
+    }>;
+    operation: z.ZodEnum<{
+        link: "link";
+        update: "update";
+        create: "create";
+        noop: "noop";
+    }>;
+    idempotency_key: z.ZodString;
+    external_type: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rel: z.ZodEnum<{
+            canonical: "canonical";
+            parent: "parent";
+            trace: "trace";
+        }>;
+        target_ref: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const backlogProjectionPlanSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    created_at: z.ZodString;
+    provider: z.ZodEnum<{
+        generic: "generic";
+        "azure-devops": "azure-devops";
+        jira: "jira";
+        trello: "trello";
+        confluence: "confluence";
+        asana: "asana";
+    }>;
+    mode: z.ZodEnum<{
+        apply: "apply";
+        "dry-run": "dry-run";
+    }>;
+    direction: z.ZodEnum<{
+        push: "push";
+        pull: "pull";
+        bidirectional: "bidirectional";
+    }>;
+    source_of_truth: z.ZodLiteral<"codesdd">;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+        provider: z.ZodEnum<{
+            generic: "generic";
+            "azure-devops": "azure-devops";
+            jira: "jira";
+            trello: "trello";
+            confluence: "confluence";
+            asana: "asana";
+        }>;
+        canonical_ref: z.ZodString;
+        entity_kind: z.ZodEnum<{
+            epic: "epic";
+            feature: "feature";
+            insight: "insight";
+            debate: "debate";
+            task: "task";
+        }>;
+        operation: z.ZodEnum<{
+            link: "link";
+            update: "update";
+            create: "create";
+            noop: "noop";
+        }>;
+        idempotency_key: z.ZodString;
+        external_type: z.ZodString;
+        fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            rel: z.ZodEnum<{
+                canonical: "canonical";
+                parent: "parent";
+                trace: "trace";
+            }>;
+            target_ref: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type BacklogProviderId = z.infer<typeof backlogProviderIdSchema>;
+export type BacklogEntityKind = z.infer<typeof backlogEntityKindSchema>;
+export type BacklogProviderCapability = z.infer<typeof backlogProviderCapabilitySchema>;
+export type BacklogProviderContract = z.infer<typeof backlogProviderContractSchema>;
+export type BacklogProviderContractInput = z.input<typeof backlogProviderContractSchema>;
+export type CanonicalBacklogItem = z.infer<typeof canonicalBacklogItemSchema>;
+export type BacklogProjectionItem = z.infer<typeof backlogProjectionItemSchema>;
+export type BacklogProjectionPlan = z.infer<typeof backlogProjectionPlanSchema>;
+export declare function createBacklogProviderContract(input: BacklogProviderContractInput): BacklogProviderContract;
+export declare function buildBacklogProjectionItem(input: {
+    contract: BacklogProviderContractInput;
+    item: CanonicalBacklogItem;
+    external_type: string;
+    operation?: BacklogProjectionItem['operation'];
+}): BacklogProjectionItem;
+//# sourceMappingURL=backlog-provider-contract.d.ts.map

package/dist/core/sdd/backlog-provider-contract.js

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+const SDD_REF_PATTERN = /^(INS|DEB|EPIC|FEAT)-\d{4}$/;
+const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+const PROVIDER_FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+export const backlogProviderIdSchema = z.enum([
+    'azure-devops',
+    'jira',
+    'trello',
+    'confluence',
+    'asana',
+    'generic',
+]);
+export const backlogEntityKindSchema = z.enum(['insight', 'debate', 'epic', 'feature', 'task']);
+export const backlogProviderOperationSchema = z.enum(['create', 'update', 'link', 'query']);
+export const backlogProjectionModeSchema = z.enum(['dry-run', 'apply']);
+export const backlogProjectionDirectionSchema = z.enum(['push', 'pull', 'bidirectional']);
+export const backlogAuthModeSchema = z.enum(['none', 'pat', 'oauth', 'managed-identity', 'app-installation']);
+export const backlogProviderCapabilitySchema = z
+    .object({
+    operation: backlogProviderOperationSchema,
+    entity_kinds: z.array(backlogEntityKindSchema).min(1),
+    dry_run: z.boolean().default(true),
+    apply: z.boolean().default(false),
+    idempotent: z.boolean().default(true),
+    required_fields: z.array(z.string().regex(PROVIDER_FIELD_PATTERN)).default([]),
+})
+    .superRefine((capability, context) => {
+    if (capability.apply && !capability.dry_run) {
+        context.addIssue({
+            code: 'custom',
+            path: ['dry_run'],
+            message: 'Apply-capable backlog provider operations must support dry-run.',
+        });
+    }
+});
+export const backlogProviderContractSchema = z
+    .object({
+    schema_version: z.literal(1).default(1),
+    provider: backlogProviderIdSchema,
+    adapter_id: z.string().regex(PROVIDER_ID_PATTERN),
+    label: z.string().min(2),
+    status: z.enum(['active', 'experimental', 'disabled']).default('experimental'),
+    auth: z.object({
+        mode: backlogAuthModeSchema,
+        required_env: z.array(z.string().min(1)).default([]),
+        secret_fields: z.array(z.string().min(1)).default([]),
+    }),
+    capabilities: z.array(backlogProviderCapabilitySchema).min(1),
+    mapping: z.object({
+        external_project_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        external_id_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        external_url_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        canonical_ref_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        parent_ref_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        entity_type_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        title_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        status_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+    }),
+    canonical_state_boundary: z.object({
+        source_of_truth: z.literal('codesdd'),
+        state_paths: z.array(z.string().min(1)).default(['.sdd/state/*.yaml']),
+        external_state_authoritative: z.literal(false),
+        hidden_state_allowed: z.literal(false),
+    }),
+    governance: z.object({
+        owner: z.string().min(2),
+        sync_requires_dry_run: z.boolean().default(true),
+        mutation_requires_approval: z.boolean().default(true),
+        audit_event: z.string().min(1).default('codesdd.backlog.projection'),
+    }),
+})
+    .superRefine((contract, context) => {
+    const seenOperations = new Set();
+    for (const [index, capability] of contract.capabilities.entries()) {
+        const key = `${capability.operation}:${capability.entity_kinds.sort().join(',')}`;
+        if (seenOperations.has(key)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['capabilities', index, 'operation'],
+                message: `Duplicate provider capability declaration: ${key}.`,
+            });
+        }
+        seenOperations.add(key);
+    }
+    if (contract.auth.mode === 'none' && contract.auth.required_env.length > 0) {
+        context.addIssue({
+            code: 'custom',
+            path: ['auth', 'required_env'],
+            message: 'Providers using auth mode none must not require credential environment variables.',
+        });
+    }
+});
+export const canonicalBacklogItemSchema = z.object({
+    ref: z.string().regex(SDD_REF_PATTERN),
+    kind: backlogEntityKindSchema.exclude(['task']),
+    title: z.string().min(1),
+    status: z.string().min(1),
+    parent_ref: z.string().regex(SDD_REF_PATTERN).optional(),
+    labels: z.array(z.string().min(1)).default([]),
+    url: z.string().url().optional(),
+});
+export const backlogProjectionItemSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    provider: backlogProviderIdSchema,
+    canonical_ref: z.string().regex(SDD_REF_PATTERN),
+    entity_kind: backlogEntityKindSchema,
+    operation: z.enum(['create', 'update', 'link', 'noop']),
+    idempotency_key: z.string().min(1),
+    external_type: z.string().min(1),
+    fields: z.record(z.string().regex(PROVIDER_FIELD_PATTERN), z.union([z.string(), z.array(z.string())])),
+    links: z
+        .array(z.object({
+        rel: z.enum(['parent', 'trace', 'canonical']),
+        target_ref: z.string().regex(SDD_REF_PATTERN),
+    }))
+        .default([]),
+});
+export const backlogProjectionPlanSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    created_at: z.string().datetime(),
+    provider: backlogProviderIdSchema,
+    mode: backlogProjectionModeSchema,
+    direction: backlogProjectionDirectionSchema,
+    source_of_truth: z.literal('codesdd'),
+    items: z.array(backlogProjectionItemSchema).default([]),
+    warnings: z.array(z.string()).default([]),
+});
+export function createBacklogProviderContract(input) {
+    return backlogProviderContractSchema.parse(input);
+}
+export function buildBacklogProjectionItem(input) {
+    const contract = createBacklogProviderContract(input.contract);
+    const item = canonicalBacklogItemSchema.parse(input.item);
+    const operation = input.operation ?? 'create';
+    const links = item.parent_ref ? [{ rel: 'parent', target_ref: item.parent_ref }] : [];
+    return backlogProjectionItemSchema.parse({
+        schema_version: 1,
+        provider: contract.provider,
+        canonical_ref: item.ref,
+        entity_kind: item.kind,
+        operation,
+        idempotency_key: `${contract.provider}:${item.ref}`,
+        external_type: input.external_type,
+        fields: {
+            [contract.mapping.canonical_ref_field]: item.ref,
+            [contract.mapping.entity_type_field]: item.kind,
+            [contract.mapping.title_field]: item.title,
+            [contract.mapping.status_field]: item.status,
+            ...(contract.mapping.parent_ref_field && item.parent_ref
+                ? { [contract.mapping.parent_ref_field]: item.parent_ref }
+                : {}),
+            ...(contract.mapping.external_url_field && item.url ? { [contract.mapping.external_url_field]: item.url } : {}),
+            labels: item.labels,
+        },
+        links,
+    });
+}
+//# sourceMappingURL=backlog-provider-contract.js.map

package/dist/core/sdd/bootstrap.js

@@ -114,7 +114,7 @@ function classifyRootEntry(name) {
         test: { kind: 'test', notes: 'Testes automatizados' },
         docs: { kind: 'docs', notes: 'Documentacao' },
         config: { kind: 'config', notes: 'Configuracoes' },
-        openspec: { kind: 'openspec', notes: 'Runtime do OpenSpec' },
+        codesdd: { kind: 'codesdd', notes: 'Runtime do CodeSDD' },
         package_json: { kind: 'manifest', notes: 'Manifesto principal' },
     };
     return map[name] || { kind: 'directory', notes: 'Diretorio detectado no projeto' };
@@ -131,7 +131,7 @@ async function inferRepoMap(projectRoot, deep) {
         'test',
         'docs',
         'config',
-        'openspec',
+        'codesdd',
     ];
     for (const candidate of rootCandidates) {
         if (await fileExists(path.join(projectRoot, candidate))) {

package/dist/core/sdd/check.d.ts

@@ -1,3 +1,5 @@
+import { type BacklogItem, type DiscoveryRecord, type FrontendGapRecord, type TechDebtRecord } from './types.js';
+import { type SddStateSnapshot } from './state.js';
 export interface SddCheckOptions {
     render?: boolean;
     strict?: boolean;
@@ -11,6 +13,8 @@ export interface SddCheckReport {
         backlog: number;
         techDebt: number;
         finalizeQueue: number;
+        finalizeQueuePending: number;
+        finalizeQueueDone: number;
         frontendEnabled: boolean;
         frontendGaps: number;
         frontendRoutes: number;
@@ -45,6 +49,46 @@ export interface SddCheckReport {
         };
     };
 }
+export declare function checkUniqueIds<T extends {
+    id: string;
+}>(items: T[], scope: string, errors: string[]): void;
+export declare function hasForbiddenTitleToken(title: string): string | null;
+export declare function validateDiscoveryRecords(records: DiscoveryRecord[], errors: string[]): void;
+export declare function validateBacklog(items: BacklogItem[], errors: string[], warnings: string[]): void;
+export declare function validateReferentialIntegrity(snapshot: SddStateSnapshot, errors: string[], warnings: string[], isStrict: boolean): void;
+export declare function validateSkillOperationalIntegrity(snapshot: SddStateSnapshot, errors: string[]): void;
+export declare function computeGraphSummary(items: BacklogItem[]): {
+    readyForParallel: number;
+    blocked: number;
+    lockConflicts: number;
+};
+export declare function roundPercent(done: number, total: number): number;
+export declare function computeProgress(items: BacklogItem[]): {
+    progressGlobal: {
+        done: number;
+        total: number;
+        percent: number;
+    };
+    progressByRadar: Array<{
+        radar_id: string;
+        done: number;
+        total: number;
+        percent: number;
+    }>;
+};
+export declare function validateTechDebt(items: TechDebtRecord[], errors: string[]): void;
+export declare function validateFrontendReferences(gaps: FrontendGapRecord[], backlog: BacklogItem[], errors: string[], warnings: string[]): void;
+export declare function validateActiveTaskChecklist(activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function validateWorkspaceCoherence(activeDir: string, archivedDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function isPrivacyComplianceBacklogItem(item: BacklogItem): boolean;
+export declare function validatePrivacySourceRegistry(snapshot: SddStateSnapshot, warnings: string[]): void;
+export declare function validatePrivacyWorkspaceChecklist(activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function validateTraceabilityWorkspaceChecklist(projectRoot: string, activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function featureRequiresQualityContract(item: BacklogItem): boolean;
+export declare function detectMissingQualityArtifacts(activeDir: string, items: BacklogItem[]): Promise<string[]>;
+export declare function parseRouteToken(value: string): string | null;
+export declare function featureHasMetadataFrontendEvidence(item: BacklogItem): boolean;
+export declare function validateCanonicalSddStructure(memoryRoot: string, errors: string[]): Promise<void>;
 export declare class SddCheckCommand {
     execute(projectRoot: string, options?: SddCheckOptions): Promise<SddCheckReport>;
 }