@lssm/app.cli-contractspec 0.0.0-canary-20251221164004 → 0.0.0-canary-20251221165922

package/dist/templates/handler.template.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate handler implementation template
+ */
+export declare function generateHandlerTemplate(specName: string, kind: 'command' | 'query'): string;
+/**
+ * Generate component template
+ */
+export declare function generateComponentTemplate(componentName: string, description: string): string;
+/**
+ * Generate test template
+ */
+export declare function generateTestTemplate(targetName: string, type: 'handler' | 'component'): string;
+//# sourceMappingURL=handler.template.d.ts.map

package/dist/templates/integration.template.d.ts

@@ -0,0 +1,3 @@
+import type { IntegrationSpecData } from '../types';
+export declare function generateIntegrationSpec(data: IntegrationSpecData): string;
+//# sourceMappingURL=integration.template.d.ts.map

package/dist/templates/knowledge.template.d.ts

@@ -0,0 +1,3 @@
+import type { KnowledgeSpaceSpecData } from '../types';
+export declare function generateKnowledgeSpaceSpec(data: KnowledgeSpaceSpecData): string;
+//# sourceMappingURL=knowledge.template.d.ts.map

package/dist/templates/migration.template.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationSpecData } from '../types';
+export declare function generateMigrationSpec(data: MigrationSpecData): string;
+//# sourceMappingURL=migration.template.d.ts.map

package/dist/templates/operation.template.d.ts

@@ -0,0 +1,6 @@
+import type { OperationSpecData } from '../types';
+/**
+ * Generate operation spec TypeScript code
+ */
+export declare function generateOperationSpec(data: OperationSpecData): string;
+//# sourceMappingURL=operation.template.d.ts.map

package/dist/templates/operation.template.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=operation.template.test.d.ts.map

package/dist/templates/presentation.template.d.ts

@@ -0,0 +1,6 @@
+import type { PresentationSpecData } from '../types';
+/**
+ * Generate presentation spec TypeScript code
+ */
+export declare function generatePresentationSpec(data: PresentationSpecData): string;
+//# sourceMappingURL=presentation.template.d.ts.map

package/dist/templates/telemetry.template.d.ts

@@ -0,0 +1,3 @@
+import type { TelemetrySpecData } from '../types';
+export declare function generateTelemetrySpec(data: TelemetrySpecData): string;
+//# sourceMappingURL=telemetry.template.d.ts.map

package/dist/templates/workflow-runner.template.d.ts

@@ -0,0 +1,9 @@
+interface RunnerTemplateOptions {
+    exportName: string;
+    specImportPath: string;
+    runnerName: string;
+    workflowName: string;
+}
+export declare function generateWorkflowRunnerTemplate({ exportName, specImportPath, runnerName, workflowName, }: RunnerTemplateOptions): string;
+export {};
+//# sourceMappingURL=workflow-runner.template.d.ts.map

package/dist/templates/workflow.template.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowSpecData } from '../types';
+export declare function generateWorkflowSpec(data: WorkflowSpecData): string;
+//# sourceMappingURL=workflow.template.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,351 @@
+export type SpecType = 'operation' | 'event' | 'presentation' | 'form' | 'feature' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config' | 'integration' | 'knowledge';
+export type OpKind = 'command' | 'query';
+export type PresentationKind = 'web_component' | 'markdown' | 'data';
+export type Stability = 'experimental' | 'beta' | 'stable' | 'deprecated';
+export type StepType = 'human' | 'automation' | 'decision';
+export interface BaseSpecData {
+    name: string;
+    version: number;
+    description: string;
+    owners: string[];
+    tags: string[];
+    stability: Stability;
+}
+export interface OperationSpecData extends BaseSpecData {
+    kind: OpKind;
+    goal: string;
+    context: string;
+    hasInput: boolean;
+    hasOutput: boolean;
+    auth: 'anonymous' | 'user' | 'admin';
+    flags: string[];
+    emitsEvents: boolean;
+}
+export interface EventSpecData extends BaseSpecData {
+    piiFields: string[];
+}
+export interface PresentationSpecData extends BaseSpecData {
+    presentationKind: PresentationKind;
+}
+export interface FormSpecData extends BaseSpecData {
+}
+export interface FeatureSpecData extends BaseSpecData {
+    key: string;
+    operations: {
+        name: string;
+        version: number;
+    }[];
+    events: {
+        name: string;
+        version: number;
+    }[];
+    presentations: {
+        name: string;
+        version: number;
+    }[];
+}
+export interface WorkflowStepData {
+    id: string;
+    label: string;
+    type: StepType;
+    description?: string;
+    operation?: {
+        name: string;
+        version: number;
+    };
+    form?: {
+        key: string;
+        version: number;
+    };
+}
+export interface WorkflowTransitionData {
+    from: string;
+    to: string;
+    condition?: string;
+}
+export interface WorkflowSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    entryStepId?: string;
+    steps: WorkflowStepData[];
+    transitions: WorkflowTransitionData[];
+    policyFlags: string[];
+}
+export type DataViewKind = 'list' | 'detail' | 'table' | 'grid';
+export interface DataViewFieldData {
+    key: string;
+    label: string;
+    dataPath: string;
+    format?: string;
+    sortable?: boolean;
+    filterable?: boolean;
+}
+export interface DataViewSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    entity: string;
+    kind: DataViewKind;
+    primaryOperation: {
+        name: string;
+        version: number;
+    };
+    itemOperation?: {
+        name: string;
+        version: number;
+    };
+    fields: DataViewFieldData[];
+    primaryField?: string;
+    secondaryFields?: string[];
+}
+export type TelemetryPrivacy = 'public' | 'internal' | 'pii' | 'sensitive';
+export interface TelemetryPropertyData {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'timestamp' | 'json';
+    required?: boolean;
+    pii?: boolean;
+    redact?: boolean;
+    description?: string;
+}
+export interface TelemetryAnomalyRuleData {
+    metric: string;
+    min?: number;
+    max?: number;
+}
+export interface TelemetryEventData {
+    name: string;
+    version: number;
+    what: string;
+    who?: string;
+    why?: string;
+    privacy: TelemetryPrivacy;
+    properties: TelemetryPropertyData[];
+    retentionDays?: number;
+    retentionPolicy?: 'archive' | 'delete';
+    samplingRate?: number;
+    samplingConditions?: string;
+    anomalyEnabled?: boolean;
+    anomalyMinimumSample?: number;
+    anomalyRules?: TelemetryAnomalyRuleData[];
+    anomalyActions?: ('alert' | 'log' | 'trigger_regen')[];
+    tags?: string[];
+}
+export interface TelemetryProviderData {
+    type: 'posthog' | 'segment' | 'opentelemetry' | 'internal';
+    config: string;
+}
+export interface TelemetrySpecData extends BaseSpecData {
+    domain: string;
+    defaultRetentionDays?: number;
+    defaultSamplingRate?: number;
+    providers?: TelemetryProviderData[];
+    anomalyEnabled?: boolean;
+    anomalyCheckIntervalMs?: number;
+    events: TelemetryEventData[];
+}
+export interface ExperimentVariantOverrideData {
+    type: 'dataView' | 'workflow' | 'theme' | 'policy' | 'presentation';
+    target: string;
+    version?: number;
+}
+export interface ExperimentVariantData {
+    id: string;
+    name: string;
+    description?: string;
+    weight?: number;
+    overrides?: ExperimentVariantOverrideData[];
+}
+export interface TargetingRuleData {
+    variantId: string;
+    percentage?: number;
+    policy?: {
+        name: string;
+        version?: number;
+    };
+    expression?: string;
+}
+export interface RandomAllocationData {
+    type: 'random';
+    salt?: string;
+}
+export interface StickyAllocationData {
+    type: 'sticky';
+    attribute: 'userId' | 'organizationId' | 'sessionId';
+    salt?: string;
+}
+export interface TargetedAllocationData {
+    type: 'targeted';
+    fallback?: 'control' | 'random';
+    rules: TargetingRuleData[];
+}
+export type ExperimentAllocationData = RandomAllocationData | StickyAllocationData | TargetedAllocationData;
+export interface ExperimentMetricData {
+    name: string;
+    eventName: string;
+    eventVersion: number;
+    aggregation: 'count' | 'avg' | 'p75' | 'p90' | 'p95' | 'p99';
+    target?: number;
+}
+export interface ExperimentSpecData extends BaseSpecData {
+    domain: string;
+    controlVariant: string;
+    variants: ExperimentVariantData[];
+    allocation: ExperimentAllocationData;
+    successMetrics?: ExperimentMetricData[];
+}
+export interface AppConfigMappingData {
+    slot: string;
+    name: string;
+    version?: number;
+}
+export interface AppConfigFeatureFlagData {
+    key: string;
+    enabled: boolean;
+    variant?: string;
+    description?: string;
+}
+export interface AppRouteConfigData {
+    path: string;
+    label?: string;
+    dataView?: string;
+    workflow?: string;
+    guardName?: string;
+    guardVersion?: number;
+    featureFlag?: string;
+    experimentName?: string;
+    experimentVersion?: number;
+}
+export interface AppBlueprintSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    appId: string;
+    capabilitiesEnabled: string[];
+    capabilitiesDisabled: string[];
+    featureIncludes: string[];
+    featureExcludes: string[];
+    dataViews: AppConfigMappingData[];
+    workflows: AppConfigMappingData[];
+    policyRefs: {
+        name: string;
+        version?: number;
+    }[];
+    theme?: {
+        name: string;
+        version: number;
+    };
+    themeFallbacks: {
+        name: string;
+        version: number;
+    }[];
+    telemetry?: {
+        name: string;
+        version?: number;
+    };
+    activeExperiments: {
+        name: string;
+        version?: number;
+    }[];
+    pausedExperiments: {
+        name: string;
+        version?: number;
+    }[];
+    featureFlags: AppConfigFeatureFlagData[];
+    routes: AppRouteConfigData[];
+    notes?: string;
+}
+export type MigrationStepKind = 'schema' | 'data' | 'validation';
+export interface MigrationStepData {
+    kind: MigrationStepKind;
+    description?: string;
+    sql?: string;
+    script?: string;
+    assertion?: string;
+    timeoutMs?: number;
+    retries?: number;
+    preChecks?: {
+        description: string;
+        expression: string;
+    }[];
+    postChecks?: {
+        description: string;
+        expression: string;
+    }[];
+}
+export interface MigrationSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    dependencies: string[];
+    up: MigrationStepData[];
+    down?: MigrationStepData[];
+}
+export type IntegrationCategoryData = 'payments' | 'email' | 'calendar' | 'sms' | 'ai-llm' | 'ai-voice' | 'speech-to-text' | 'vector-db' | 'storage' | 'accounting' | 'crm' | 'helpdesk' | 'open-banking' | 'custom';
+export type IntegrationConfigFieldType = 'string' | 'number' | 'boolean';
+export type IntegrationOwnershipModeData = 'managed' | 'byok';
+export type IntegrationHealthCheckMethod = 'ping' | 'list' | 'custom';
+export interface IntegrationCapabilityRefData {
+    key: string;
+    version: number;
+}
+export interface IntegrationCapabilityRequirementData {
+    key: string;
+    version?: number;
+    optional?: boolean;
+    reason?: string;
+}
+export interface IntegrationConfigFieldData {
+    key: string;
+    type: IntegrationConfigFieldType;
+    required: boolean;
+    description?: string;
+}
+export interface IntegrationSecretFieldData extends IntegrationConfigFieldData {
+}
+export interface IntegrationSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    displayName: string;
+    category: IntegrationCategoryData;
+    supportedModes: IntegrationOwnershipModeData[];
+    capabilitiesProvided: IntegrationCapabilityRefData[];
+    capabilitiesRequired: IntegrationCapabilityRequirementData[];
+    configFields: IntegrationConfigFieldData[];
+    secretFields: IntegrationSecretFieldData[];
+    docsUrl?: string;
+    rateLimitRpm?: number;
+    rateLimitRph?: number;
+    healthCheckMethod: IntegrationHealthCheckMethod;
+    healthCheckTimeoutMs?: number;
+    byokSetupInstructions?: string;
+    byokRequiredScopes?: string[];
+}
+export type KnowledgeCategoryData = 'canonical' | 'operational' | 'external' | 'ephemeral';
+export type KnowledgeTrustLevel = 'high' | 'medium' | 'low';
+export interface KnowledgeRetentionData {
+    ttlDays?: number | null;
+    archiveAfterDays?: number;
+}
+export interface KnowledgeSpaceSpecData extends BaseSpecData {
+    title: string;
+    domain: string;
+    displayName: string;
+    category: KnowledgeCategoryData;
+    retention: KnowledgeRetentionData;
+    policyName?: string;
+    policyVersion?: number;
+    trustLevel: KnowledgeTrustLevel;
+    automationWritable: boolean;
+    embeddingModel?: string;
+    chunkSize?: number;
+    vectorDbIntegration?: string;
+}
+export interface AIGenerationOptions {
+    provider: 'claude' | 'openai' | 'ollama' | 'custom';
+    model?: string;
+    endpoint?: string;
+    stream?: boolean;
+}
+export interface GenerationResult {
+    code: string;
+    filePath: string;
+    specType: SpecType;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/config-writer.d.ts

@@ -0,0 +1,25 @@
+import type { Config } from './config';
+import type { OpenApiSourceConfig } from '@lssm/lib.contracts';
+/**
+ * Read the current config file, or return an empty object if it doesn't exist.
+ */
+export declare function readConfigFile(cwd?: string): Promise<Partial<Config>>;
+/**
+ * Write the config file.
+ */
+export declare function writeConfigFile(config: Partial<Config>, cwd?: string): Promise<void>;
+/**
+ * Upsert an OpenAPI source in the config.
+ * If a source with the same name exists, it is updated.
+ * Otherwise, the source is added.
+ */
+export declare function upsertOpenApiSource(source: OpenApiSourceConfig, cwd?: string): Promise<void>;
+/**
+ * Get all configured OpenAPI sources.
+ */
+export declare function getOpenApiSources(cwd?: string): Promise<OpenApiSourceConfig[]>;
+/**
+ * Get the output directory for a spec type based on conventions.
+ */
+export declare function getOutputDirForSpecType(specType: 'operation' | 'event' | 'presentation' | 'form' | 'model', config: Config): string;
+//# sourceMappingURL=config-writer.d.ts.map

package/dist/utils/config.d.ts

@@ -0,0 +1,54 @@
+import { type PackageManager } from '@lssm/bundle.contractspec-workspace';
+import { type ContractsrcConfig, type FolderConventions, type OpenApiConfig, type OpenApiSourceConfig } from '@lssm/lib.contracts';
+export type { OpenApiSourceConfig, OpenApiConfig, FolderConventions };
+export type Config = ContractsrcConfig;
+/**
+ * Configuration with workspace context.
+ */
+export interface ConfigWithWorkspace extends Config {
+    /**
+     * Detected package manager.
+     */
+    packageManager: PackageManager;
+    /**
+     * Workspace root (monorepo root or package root).
+     */
+    workspaceRoot: string;
+    /**
+     * Current package root.
+     */
+    packageRoot: string;
+    /**
+     * Whether this is a monorepo.
+     */
+    isMonorepo: boolean;
+}
+/**
+ * Load configuration from .contractsrc.json with monorepo support.
+ *
+ * Searches for config in the following order:
+ * 1. Package root (.contractsrc.json in the nearest package.json directory)
+ * 2. Workspace root (.contractsrc.json in the workspace/monorepo root)
+ *
+ * Package config is merged on top of workspace config.
+ */
+export declare function loadConfig(cwd?: string): Promise<Config>;
+/**
+ * Load configuration with workspace context.
+ */
+export declare function loadConfigWithWorkspace(cwd?: string): Promise<ConfigWithWorkspace>;
+/**
+ * Merge config with CLI options and environment variables
+ */
+export declare function mergeConfig(config: Config, options: {
+    provider?: string;
+    model?: string;
+    agentMode?: string;
+    endpoint?: string;
+    outputDir?: string;
+}): Config;
+/**
+ * Get API key for the configured provider
+ */
+export declare function getApiKey(provider: Config['aiProvider']): string | undefined;
+//# sourceMappingURL=config.d.ts.map

package/dist/utils/dynamicImport.d.ts

@@ -0,0 +1,2 @@
+export declare function dynamicImport(path: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=dynamicImport.d.ts.map

package/dist/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/fs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Ensure directory exists, creating it if necessary
+ */
+export declare function ensureDir(path: string): Promise<void>;
+/**
+ * Write file, creating parent directories if needed
+ */
+export declare function writeFileSafe(filePath: string, content: string): Promise<void>;
+/**
+ * Resolve output path based on config and spec type
+ */
+export declare function resolveOutputPath(basePath: string, specType: 'operation' | 'event' | 'presentation' | 'form' | 'feature' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config' | 'integration' | 'knowledge', conventions: Record<string, unknown>, fileName: string): string;
+/**
+ * Generate unique filename to avoid conflicts
+ */
+export declare function generateFileName(baseName: string, extension?: string): string;
+export declare function resolvePathFromCwd(targetPath: string): string;
+//# sourceMappingURL=fs.d.ts.map

package/dist/utils/module-loader.d.ts

@@ -0,0 +1,2 @@
+export declare function loadTypeScriptModule(filePath: string): Promise<any>;
+//# sourceMappingURL=module-loader.d.ts.map

package/dist/utils/runtime.d.ts

@@ -0,0 +1,31 @@
+export type RuntimeKind = 'bun' | 'node';
+/**
+ * Detect the current JavaScript runtime.
+ */
+export declare function detectRuntime(): RuntimeKind;
+/**
+ * Check if running in Bun runtime.
+ */
+export declare function isBunRuntime(): boolean;
+/**
+ * Check if running in Node.js runtime.
+ */
+export declare function isNodeRuntime(): boolean;
+/**
+ * Get the runtime version.
+ */
+export declare function getRuntimeVersion(): string;
+/**
+ * Get Node.js-compatible APIs that work in both runtimes.
+ */
+export declare function getCompatibleApis(): {
+    /**
+     * Dynamic import that works in both Bun and Node.js.
+     */
+    dynamicImport: <T = unknown>(specifier: string) => Promise<T>;
+    /**
+     * Resolve module path (uses import.meta.resolve in both runtimes).
+     */
+    resolveModule: (specifier: string, parent?: string) => string;
+};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/utils/spec-files.d.ts

@@ -0,0 +1,5 @@
+export interface SpecDiscoveryOptions {
+    pattern?: string;
+}
+export declare function discoverSpecFiles(options?: SpecDiscoveryOptions): Promise<string[]>;
+//# sourceMappingURL=spec-files.d.ts.map

package/dist/utils/spec-load.d.ts

@@ -0,0 +1,4 @@
+export type LoadedModule = Record<string, unknown>;
+export declare function loadSpecModule(filePath: string): Promise<LoadedModule>;
+export declare function pickSpecExport(mod: LoadedModule): unknown;
+//# sourceMappingURL=spec-load.d.ts.map

package/dist/utils/spec-scan.d.ts

@@ -0,0 +1,23 @@
+export type SpecType = 'operation' | 'event' | 'presentation' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config' | 'integration' | 'knowledge' | 'unknown';
+export type OperationKind = 'command' | 'query' | 'unknown';
+export type Stability = 'experimental' | 'beta' | 'stable' | 'deprecated';
+export interface SpecScanResult {
+    filePath: string;
+    specType: SpecType;
+    name?: string;
+    version?: number;
+    kind?: OperationKind;
+    stability?: Stability;
+    description?: string;
+    owners?: string[];
+    tags?: string[];
+    hasMeta: boolean;
+    hasIo: boolean;
+    hasPolicy: boolean;
+    hasPayload: boolean;
+    hasContent: boolean;
+    hasDefinition: boolean;
+}
+export declare function inferSpecTypeFromFilePath(filePath: string): SpecType;
+export declare function scanSpecSource(code: string, filePath: string): SpecScanResult;
+//# sourceMappingURL=spec-scan.d.ts.map

package/dist/utils/spec-scan.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spec-scan.test.d.ts.map

package/dist/utils/validation.d.ts

@@ -0,0 +1,32 @@
+import * as z from 'zod';
+/**
+ * Validate that a string is a valid TypeScript identifier
+ */
+export declare function isValidIdentifier(str: string): boolean;
+/**
+ * Validate that a string is a valid dot-notation name (e.g., "user.signup")
+ */
+export declare function isValidDotName(str: string): boolean;
+/**
+ * Validate version number
+ */
+export declare function isValidVersion(version: number): boolean;
+/**
+ * Validate email format
+ */
+export declare const emailSchema: z.ZodString;
+/**
+ * Validate URL format
+ */
+export declare const urlSchema: z.ZodString;
+/**
+ * Common validation schemas
+ */
+export declare const validators: {
+    specName: z.ZodString;
+    version: z.ZodNumber;
+    identifier: z.ZodString;
+    owner: z.ZodString;
+    tag: z.ZodString;
+};
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.test.d.ts.map