@contractspec/lib.contracts-spec 2.0.0

package/dist/workspace-config/contractsrc-schema.js

@@ -0,0 +1,344 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+// src/workspace-config/contractsrc-schema.ts
+import * as z from "zod";
+var SchemaFormatSchema = z.enum([
+  "contractspec",
+  "zod",
+  "json-schema",
+  "graphql"
+]);
+var OpenApiSourceConfigSchema = z.object({
+  name: z.string(),
+  url: z.string().url().optional(),
+  file: z.string().optional(),
+  syncMode: z.enum(["import", "sync", "validate"]).default("validate").optional(),
+  tags: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional(),
+  include: z.array(z.string()).optional(),
+  prefix: z.string().optional(),
+  defaultStability: z.enum(["experimental", "beta", "stable", "deprecated"]).optional(),
+  defaultAuth: z.enum(["anonymous", "user", "admin"]).optional(),
+  defaultOwners: z.array(z.string()).optional(),
+  schemaFormat: SchemaFormatSchema.default("contractspec").optional()
+});
+var OpenApiExportConfigSchema = z.object({
+  outputPath: z.string().default("./openapi.json").optional(),
+  format: z.enum(["json", "yaml"]).default("json").optional(),
+  title: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  servers: z.array(z.object({
+    url: z.string(),
+    description: z.string().optional()
+  })).optional()
+});
+var OpenApiConfigSchema = z.object({
+  sources: z.array(OpenApiSourceConfigSchema).optional(),
+  export: OpenApiExportConfigSchema.optional()
+});
+var GroupingStrategySchema = z.enum([
+  "by-tag",
+  "by-owner",
+  "by-domain",
+  "by-url-path-single",
+  "by-url-path-multi",
+  "by-feature",
+  "none"
+]);
+var GroupingRuleSchema = z.object({
+  strategy: GroupingStrategySchema,
+  urlPathLevel: z.number().optional(),
+  pattern: z.string().optional()
+});
+var FolderConventionsSchema = z.object({
+  models: z.string().default("models").optional(),
+  operations: z.string().default("operations/commands|queries").optional(),
+  events: z.string().default("events").optional(),
+  presentations: z.string().default("presentations").optional(),
+  forms: z.string().default("forms").optional(),
+  groupByFeature: z.boolean().default(true).optional(),
+  operationsGrouping: GroupingRuleSchema.optional(),
+  modelsGrouping: GroupingRuleSchema.optional(),
+  eventsGrouping: GroupingRuleSchema.optional()
+});
+var PrCommentConfigSchema = z.object({
+  enabled: z.boolean().default(true).optional(),
+  template: z.enum(["minimal", "detailed"]).default("detailed").optional(),
+  updateExisting: z.boolean().default(true).optional()
+});
+var CheckRunConfigSchema = z.object({
+  enabled: z.boolean().default(true).optional(),
+  name: z.string().default("ContractSpec Impact").optional(),
+  failOnBreaking: z.boolean().default(true).optional(),
+  failOnChanges: z.boolean().default(false).optional()
+});
+var ImpactConfigSchema = z.object({
+  baseline: z.string().default("default-branch").optional(),
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional()
+});
+var CiConfigSchema = z.object({
+  checks: z.array(z.string()).default(["structure", "integrity", "deps"]).optional(),
+  skipChecks: z.array(z.string()).optional(),
+  failOnWarnings: z.boolean().default(false).optional(),
+  uploadSarif: z.boolean().default(true).optional(),
+  prComment: PrCommentConfigSchema.optional(),
+  checkRun: CheckRunConfigSchema.optional(),
+  impact: ImpactConfigSchema.optional()
+});
+var ExternalWorkspaceSchema = z.object({
+  alias: z.string(),
+  submodule: z.string(),
+  packages: z.array(z.string()).optional(),
+  autoResolve: z.boolean().default(true).optional()
+});
+var MetaRepoConfigSchema = z.object({
+  activeScope: z.string().optional(),
+  externalWorkspaces: z.array(ExternalWorkspaceSchema).optional(),
+  crossWorkspaceSearch: z.boolean().default(false).optional()
+});
+var FormatterTypeSchema = z.enum([
+  "prettier",
+  "eslint",
+  "biome",
+  "dprint",
+  "custom"
+]);
+var FormatterConfigSchema = z.object({
+  enabled: z.boolean().default(true).optional(),
+  type: FormatterTypeSchema.optional(),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  timeout: z.number().default(30000).optional()
+});
+var BumpStrategySchema = z.enum([
+  "impact",
+  "conventional"
+]);
+var ChangelogFormatSchema = z.enum([
+  "keep-a-changelog",
+  "conventional",
+  "custom"
+]);
+var ChangelogTierSchema = z.enum([
+  "spec",
+  "library",
+  "monorepo"
+]);
+var VersioningConfigSchema = z.object({
+  autoBump: z.boolean().default(false).optional(),
+  bumpStrategy: BumpStrategySchema.default("impact").optional(),
+  integrateWithChangesets: z.boolean().default(false).optional(),
+  changelogTiers: z.array(ChangelogTierSchema).default(["spec", "library", "monorepo"]).optional(),
+  format: ChangelogFormatSchema.default("keep-a-changelog").optional(),
+  commitChanges: z.boolean().default(false).optional(),
+  commitMessage: z.string().default("chore: bump spec versions").optional(),
+  createTags: z.boolean().default(false).optional(),
+  tagPrefix: z.string().default("v").optional(),
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional()
+});
+var RuleSyncTargetSchema = z.enum([
+  "cursor",
+  "windsurf",
+  "cline",
+  "claude-code",
+  "copilot",
+  "subagent",
+  "skill"
+]);
+var RuleSyncConfigSchema = z.object({
+  enabled: z.boolean().default(false).optional(),
+  rulesDir: z.string().default("./.rules").optional(),
+  rules: z.array(z.string()).default(["**/*.rule.md"]).optional(),
+  targets: z.array(RuleSyncTargetSchema).default(["cursor", "windsurf"]).optional(),
+  autoSync: z.boolean().default(true).optional(),
+  ejectMode: z.boolean().default(false).optional()
+});
+var ClaudeAgentSDKConfigSchema = z.object({
+  enabled: z.boolean().default(false).optional(),
+  apiKey: z.string().optional(),
+  model: z.string().default("claude-sonnet-4-20250514").optional(),
+  computerUse: z.boolean().default(false).optional(),
+  extendedThinking: z.boolean().default(false).optional()
+});
+var OpenCodeSDKConfigSchema = z.object({
+  enabled: z.boolean().default(false).optional(),
+  serverUrl: z.string().optional(),
+  port: z.number().optional(),
+  agentType: z.enum(["build", "plan", "general", "explore"]).default("general").optional(),
+  model: z.string().optional()
+});
+var ExternalAgentsConfigSchema = z.object({
+  claudeAgent: ClaudeAgentSDKConfigSchema.optional(),
+  openCode: OpenCodeSDKConfigSchema.optional()
+});
+var RuleSeveritySchema = z.enum([
+  "off",
+  "warn",
+  "error"
+]);
+var SpecKindSchema = z.enum([
+  "operation",
+  "event",
+  "presentation",
+  "feature",
+  "workflow",
+  "data-view",
+  "migration",
+  "telemetry",
+  "experiment",
+  "app-config"
+]);
+var LintRulesSchema = z.object({
+  "require-acceptance": RuleSeveritySchema.optional(),
+  "require-examples": RuleSeveritySchema.optional(),
+  "require-stability": RuleSeveritySchema.optional(),
+  "require-owners-format": RuleSeveritySchema.optional(),
+  "event-past-tense": RuleSeveritySchema.optional(),
+  "no-todo": RuleSeveritySchema.optional(),
+  "workflow-transitions": RuleSeveritySchema.optional(),
+  "telemetry-privacy": RuleSeveritySchema.optional(),
+  "experiment-allocation": RuleSeveritySchema.optional(),
+  "app-config-appid": RuleSeveritySchema.optional(),
+  "app-config-capabilities": RuleSeveritySchema.optional(),
+  "data-view-fields": RuleSeveritySchema.optional()
+});
+var TestLinkingStrategySchema = z.enum([
+  "target-first",
+  "convention-only",
+  "both"
+]);
+var TestLinkingConfigSchema = z.object({
+  strategy: TestLinkingStrategySchema.default("both").optional(),
+  warnOnConvention: z.boolean().default(false).optional()
+});
+var TestingConfigSchema = z.object({
+  runner: z.enum(["internal", "jest", "vitest", "bun"]).default("internal").optional(),
+  testMatch: z.array(z.string()).default(["**/*.{test,spec}.{ts,js}"]).optional(),
+  autoGenerate: z.boolean().default(false).optional(),
+  integrity: z.object({
+    requireTestsFor: z.array(SpecKindSchema).optional(),
+    minCoverage: z.number().optional()
+  }).optional(),
+  testLinking: TestLinkingConfigSchema.optional()
+});
+var RulesConfigSchema = z.object({
+  defaults: LintRulesSchema.optional(),
+  overrides: z.record(SpecKindSchema, LintRulesSchema).optional()
+});
+var HooksConfigSchema = z.record(z.string(), z.array(z.string()));
+var ContractsrcSchema = z.object({
+  aiProvider: z.enum(["claude", "openai", "ollama", "custom"]).default("claude").optional(),
+  aiModel: z.string().optional(),
+  agentMode: z.enum([
+    "simple",
+    "cursor",
+    "claude-code",
+    "openai-codex",
+    "claude-agent-sdk",
+    "opencode",
+    "opencode-sdk"
+  ]).default("simple").optional(),
+  customEndpoint: z.url().nullable().optional(),
+  customApiKey: z.string().nullable().optional(),
+  outputDir: z.string().default("./src").optional(),
+  conventions: FolderConventionsSchema.optional(),
+  defaultOwners: z.array(z.string()).default([]).optional(),
+  defaultTags: z.array(z.string()).default([]).optional(),
+  packages: z.array(z.string()).optional(),
+  excludePackages: z.array(z.string()).optional(),
+  recursive: z.boolean().optional(),
+  openapi: OpenApiConfigSchema.optional(),
+  ci: CiConfigSchema.optional(),
+  metaRepo: MetaRepoConfigSchema.optional(),
+  rules: RulesConfigSchema.optional(),
+  testing: TestingConfigSchema.optional(),
+  hooks: HooksConfigSchema.optional(),
+  schemaFormat: SchemaFormatSchema.default("contractspec").optional(),
+  formatter: FormatterConfigSchema.optional(),
+  versioning: VersioningConfigSchema.optional(),
+  ruleSync: RuleSyncConfigSchema.optional(),
+  externalAgents: ExternalAgentsConfigSchema.optional()
+});
+var DEFAULT_CONTRACTSRC = {
+  aiProvider: "claude",
+  agentMode: "simple",
+  outputDir: "./src",
+  conventions: {
+    models: "models",
+    operations: "interactions/commands|queries",
+    events: "events",
+    presentations: "presentations",
+    forms: "forms",
+    groupByFeature: true
+  },
+  defaultOwners: [],
+  defaultTags: [],
+  schemaFormat: "contractspec"
+};
+export {
+  VersioningConfigSchema,
+  TestingConfigSchema,
+  TestLinkingStrategySchema,
+  TestLinkingConfigSchema,
+  SpecKindSchema,
+  SchemaFormatSchema,
+  RulesConfigSchema,
+  RuleSyncTargetSchema,
+  RuleSyncConfigSchema,
+  RuleSeveritySchema,
+  PrCommentConfigSchema,
+  OpenCodeSDKConfigSchema,
+  OpenApiSourceConfigSchema,
+  OpenApiExportConfigSchema,
+  OpenApiConfigSchema,
+  MetaRepoConfigSchema,
+  LintRulesSchema,
+  ImpactConfigSchema,
+  HooksConfigSchema,
+  GroupingStrategySchema,
+  GroupingRuleSchema,
+  FormatterTypeSchema,
+  FormatterConfigSchema,
+  FolderConventionsSchema,
+  ExternalWorkspaceSchema,
+  ExternalAgentsConfigSchema,
+  DEFAULT_CONTRACTSRC,
+  ContractsrcSchema,
+  ClaudeAgentSDKConfigSchema,
+  CiConfigSchema,
+  CheckRunConfigSchema,
+  ChangelogTierSchema,
+  ChangelogFormatSchema,
+  BumpStrategySchema
+};

package/dist/workspace-config/contractsrc-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workspace-config/contractsrc-types.d.ts

@@ -0,0 +1,342 @@
+/**
+ * Explicit type definitions for ContractSpec configuration.
+ *
+ * These interfaces mirror the Zod schemas in `contractsrc-schema.ts` but are
+ * statically defined to reduce compiler inference cost and memory usage.
+ */
+export type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
+export type GroupingStrategy = 'by-tag' | 'by-owner' | 'by-domain' | 'by-url-path-single' | 'by-url-path-multi' | 'by-feature' | 'none';
+export type FormatterType = 'prettier' | 'eslint' | 'biome' | 'dprint' | 'custom';
+export type BumpStrategy = 'impact' | 'conventional';
+export type ChangelogFormat = 'keep-a-changelog' | 'conventional' | 'custom';
+export type ChangelogTier = 'spec' | 'library' | 'monorepo';
+export type RuleSyncTarget = 'cursor' | 'windsurf' | 'cline' | 'claude-code' | 'copilot' | 'subagent' | 'skill';
+export type RuleSeverity = 'off' | 'warn' | 'error';
+export type SpecKind = 'operation' | 'event' | 'presentation' | 'feature' | 'workflow' | 'data-view' | 'migration' | 'telemetry' | 'experiment' | 'app-config';
+export type TestLinkingStrategy = 'target-first' | 'convention-only' | 'both';
+export type AgentProvider = 'claude' | 'openai' | 'ollama' | 'custom';
+export type AgentMode = 'simple' | 'cursor' | 'claude-code' | 'openai-codex' | 'claude-agent-sdk' | 'opencode' | 'opencode-sdk';
+export interface OpenApiSourceConfig {
+    /** Friendly name for the source */
+    name: string;
+    /** Remote URL to fetch OpenAPI spec from */
+    url?: string;
+    /** Local file path to OpenAPI spec */
+    file?: string;
+    /** Sync mode: import (one-time), sync (update), validate (check only) */
+    syncMode?: 'import' | 'sync' | 'validate';
+    /** Only import operations with these tags */
+    tags?: string[];
+    /** Exclude operations with these operationIds */
+    exclude?: string[];
+    /** Include operations with these operationIds (overrides exclude) */
+    include?: string[];
+    /** Prefix for generated spec names */
+    prefix?: string;
+    /** Default stability for imported specs */
+    defaultStability?: 'experimental' | 'beta' | 'stable' | 'deprecated';
+    /** Default auth level for imported specs */
+    defaultAuth?: 'anonymous' | 'user' | 'admin';
+    /** Default owners for imported specs */
+    defaultOwners?: string[];
+    /** Output schema format for generated models */
+    schemaFormat?: SchemaFormat;
+}
+export interface OpenApiExportConfig {
+    /** Output path for exported OpenAPI document */
+    outputPath?: string;
+    /** Output format */
+    format?: 'json' | 'yaml';
+    /** API title for export */
+    title?: string;
+    /** API version for export */
+    version?: string;
+    /** API description for export */
+    description?: string;
+    /** Server URLs to include in export */
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+}
+export interface OpenApiConfig {
+    /** External OpenAPI sources to import/sync from */
+    sources?: OpenApiSourceConfig[];
+    /** Export configuration */
+    export?: OpenApiExportConfig;
+}
+export interface GroupingRule {
+    /** Grouping strategy to apply */
+    strategy: GroupingStrategy;
+    /** For url-path strategies, the level depth (default: 1) */
+    urlPathLevel?: number;
+    /** Custom key extraction pattern (regex or glob) */
+    pattern?: string;
+}
+export interface FolderConventions {
+    models?: string;
+    operations?: string;
+    events?: string;
+    presentations?: string;
+    forms?: string;
+    /** Enable feature/module folder grouping (default: true) */
+    groupByFeature?: boolean;
+    /** Grouping rule for operations */
+    operationsGrouping?: GroupingRule;
+    /** Grouping rule for models */
+    modelsGrouping?: GroupingRule;
+    /** Grouping rule for events */
+    eventsGrouping?: GroupingRule;
+}
+export interface PrCommentConfig {
+    /** Enable PR comments */
+    enabled?: boolean;
+    /** Comment template: 'minimal' | 'detailed' */
+    template?: 'minimal' | 'detailed';
+    /** Update existing comment instead of creating new */
+    updateExisting?: boolean;
+}
+export interface CheckRunConfig {
+    /** Enable GitHub check run creation */
+    enabled?: boolean;
+    /** Check run name */
+    name?: string;
+    /** Fail check on breaking changes */
+    failOnBreaking?: boolean;
+    /** Fail check on any contract changes */
+    failOnChanges?: boolean;
+}
+export interface ImpactConfig {
+    /** Baseline for comparison: 'default-branch' | 'base-ref' | 'tag:v*' */
+    baseline?: string;
+    /** Paths to include in impact detection (glob patterns) */
+    include?: string[];
+    /** Paths to exclude from impact detection (glob patterns) */
+    exclude?: string[];
+}
+export interface CiConfig {
+    /** Default checks to run */
+    checks?: string[];
+    /** Checks to skip */
+    skipChecks?: string[];
+    /** Fail CI on warnings */
+    failOnWarnings?: boolean;
+    /** Upload SARIF to GitHub Code Scanning */
+    uploadSarif?: boolean;
+    /** PR comment configuration */
+    prComment?: PrCommentConfig;
+    /** GitHub check run configuration */
+    checkRun?: CheckRunConfig;
+    /** Impact detection configuration */
+    impact?: ImpactConfig;
+}
+export interface ExternalWorkspace {
+    /** Alias for referencing this workspace (e.g., 'core', 'internal') */
+    alias: string;
+    /** Submodule name or relative path from meta-repo root */
+    submodule: string;
+    /** Package patterns to include from this workspace */
+    packages?: string[];
+    /** Whether to auto-resolve internal dependencies */
+    autoResolve?: boolean;
+}
+export interface MetaRepoConfig {
+    /** Active submodule scope (defaults to auto-detected) */
+    activeScope?: string;
+    /** External workspace references for cross-workspace dependencies */
+    externalWorkspaces?: ExternalWorkspace[];
+    /** Whether to search for specs across all submodules */
+    crossWorkspaceSearch?: boolean;
+}
+export interface FormatterConfig {
+    /** Enable/disable formatting (default: true if formatter detected) */
+    enabled?: boolean;
+    /** Formatter to use (auto-detected if not specified) */
+    type?: FormatterType;
+    /** Custom command for 'custom' type (e.g., "bunx prettier --write") */
+    command?: string;
+    /** Extra arguments to pass to formatter */
+    args?: string[];
+    /** Timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+export interface VersioningConfig {
+    /** Enable automated version bumping in CI */
+    autoBump?: boolean;
+    /** Strategy for determining version bumps */
+    bumpStrategy?: BumpStrategy;
+    /** Integrate with Changesets (generate .changeset files) */
+    integrateWithChangesets?: boolean;
+    /** Changelog tiers to generate */
+    changelogTiers?: ChangelogTier[];
+    /** Changelog format template */
+    format?: ChangelogFormat;
+    /** Commit changes after version bump (CI mode) */
+    commitChanges?: boolean;
+    /** Commit message template (supports {version}, {specs}) */
+    commitMessage?: string;
+    /** Create git tags for versions */
+    createTags?: boolean;
+    /** Tag prefix (e.g., "v" -> v1.0.0, "spec-" -> spec-1.0.0) */
+    tagPrefix?: string;
+    /** Paths to include for version analysis (glob patterns) */
+    include?: string[];
+    /** Paths to exclude from version analysis (glob patterns) */
+    exclude?: string[];
+}
+export interface RuleSyncConfig {
+    /** Enable automated rule synchronization */
+    enabled?: boolean;
+    /** Root directory for source rule files */
+    rulesDir?: string;
+    /** Source rule files (glob patterns) */
+    rules?: string[];
+    /** Synchronization targets (tools to generate rules for) */
+    targets?: RuleSyncTarget[];
+    /** Automatically synchronize rules on workspace changes or builds */
+    autoSync?: boolean;
+    /** Whether to eject/copy source rules instead of generating from Unified Rules */
+    ejectMode?: boolean;
+}
+export interface ClaudeAgentSDKConfig {
+    /** Enable Claude Agent SDK provider */
+    enabled?: boolean;
+    /** API key (defaults to ANTHROPIC_API_KEY env var) */
+    apiKey?: string;
+    /** Model to use (defaults to claude-sonnet-4-20250514) */
+    model?: string;
+    /** Enable computer use capabilities */
+    computerUse?: boolean;
+    /** Enable extended thinking mode */
+    extendedThinking?: boolean;
+}
+export interface OpenCodeSDKConfig {
+    /** Enable OpenCode SDK provider */
+    enabled?: boolean;
+    /** Server URL (defaults to http://127.0.0.1:4096) */
+    serverUrl?: string;
+    /** Server port (alternative to full URL) */
+    port?: number;
+    /** Agent type to use */
+    agentType?: 'build' | 'plan' | 'general' | 'explore';
+    /** Model to use */
+    model?: string;
+}
+export interface ExternalAgentsConfig {
+    /** Claude Agent SDK configuration */
+    claudeAgent?: ClaudeAgentSDKConfig;
+    /** OpenCode SDK configuration */
+    openCode?: OpenCodeSDKConfig;
+}
+export interface LintRules {
+    /** Require acceptance scenarios for operations */
+    'require-acceptance'?: RuleSeverity;
+    /** Require examples for operations */
+    'require-examples'?: RuleSeverity;
+    /** Require stability field */
+    'require-stability'?: RuleSeverity;
+    /** Require owners to follow proper format (@team or Enum) */
+    'require-owners-format'?: RuleSeverity;
+    /** Require event names to use past tense */
+    'event-past-tense'?: RuleSeverity;
+    /** Warn on placeholder comments */
+    'no-todo'?: RuleSeverity;
+    /** Require workflow transitions */
+    'workflow-transitions'?: RuleSeverity;
+    /** Require privacy classification for telemetry */
+    'telemetry-privacy'?: RuleSeverity;
+    /** Require allocation config for experiments */
+    'experiment-allocation'?: RuleSeverity;
+    /** Require appId for app blueprints */
+    'app-config-appid'?: RuleSeverity;
+    /** Require capabilities for app blueprints */
+    'app-config-capabilities'?: RuleSeverity;
+    /** Require fields for data views */
+    'data-view-fields'?: RuleSeverity;
+}
+export interface TestLinkingConfig {
+    /** Strategy for linking tests to specs */
+    strategy?: TestLinkingStrategy;
+    /** Warn when tests only use naming convention (no TestSpec.target) */
+    warnOnConvention?: boolean;
+}
+export interface TestingConfig {
+    /** Test runner to use */
+    runner?: 'internal' | 'jest' | 'vitest' | 'bun';
+    /** Glob patterns for matching test files */
+    testMatch?: string[];
+    /** Enable automatic test generation */
+    autoGenerate?: boolean;
+    /** Integrity requirements for testing */
+    integrity?: {
+        /** Spec types that require test coverage */
+        requireTestsFor?: SpecKind[];
+        /** Minimum coverage percentage (if supported) */
+        minCoverage?: number;
+    };
+    /** Test linking configuration for contract-first test discovery */
+    testLinking?: TestLinkingConfig;
+}
+export interface RulesConfig {
+    /** Global default rule severities */
+    defaults?: LintRules;
+    /** Per-kind rule severity overrides */
+    overrides?: Partial<Record<SpecKind, LintRules>>;
+}
+export type HooksConfig = Record<string, string[]>;
+/**
+ * Full ContractSpec configuration (.contractsrc.json).
+ * All fields are optional as they come from user configuration.
+ */
+export interface ContractsrcFileConfig {
+    aiProvider?: AgentProvider;
+    aiModel?: string;
+    agentMode?: AgentMode;
+    customEndpoint?: string | null;
+    customApiKey?: string | null;
+    outputDir?: string;
+    conventions?: FolderConventions;
+    defaultOwners?: string[];
+    defaultTags?: string[];
+    packages?: string[];
+    excludePackages?: string[];
+    recursive?: boolean;
+    openapi?: OpenApiConfig;
+    ci?: CiConfig;
+    metaRepo?: MetaRepoConfig;
+    rules?: RulesConfig;
+    testing?: TestingConfig;
+    hooks?: HooksConfig;
+    schemaFormat?: SchemaFormat;
+    formatter?: FormatterConfig;
+    versioning?: VersioningConfig;
+    ruleSync?: RuleSyncConfig;
+    externalAgents?: ExternalAgentsConfig;
+}
+/**
+ * Resolved configuration with guaranteed defaults.
+ * This is what the application uses at runtime.
+ */
+export interface ResolvedContractsrcConfig extends ContractsrcFileConfig {
+    aiProvider: 'claude' | 'openai' | 'ollama' | 'custom';
+    agentMode: 'simple' | 'cursor' | 'claude-code' | 'openai-codex' | 'claude-agent-sdk' | 'opencode' | 'opencode-sdk';
+    outputDir: string;
+    conventions: {
+        models: string;
+        operations: string;
+        events: string;
+        presentations: string;
+        forms: string;
+        groupByFeature: boolean;
+        operationsGrouping?: GroupingRule;
+        modelsGrouping?: GroupingRule;
+        eventsGrouping?: GroupingRule;
+    };
+    defaultOwners: string[];
+    defaultTags: string[];
+    schemaFormat: SchemaFormat;
+}
+/**
+ * @deprecated Use ContractsrcFileConfig for file inputs or ResolvedContractsrcConfig for app usage.
+ */
+export type ContractsrcConfig = ContractsrcFileConfig;

package/dist/workspace-config/contractsrc-types.js

@@ -0,0 +1 @@
+// @bun

package/dist/workspace-config/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration module exports.
+ */
+export type { AgentMode, AgentProvider } from './contractsrc-types';
+export { OpenApiSourceConfigSchema, OpenApiExportConfigSchema, OpenApiConfigSchema, FolderConventionsSchema, ContractsrcSchema, SchemaFormatSchema, FormatterTypeSchema, FormatterConfigSchema, BumpStrategySchema, ChangelogFormatSchema, ChangelogTierSchema, VersioningConfigSchema, RuleSyncTargetSchema, RuleSyncConfigSchema, DEFAULT_CONTRACTSRC, type OpenApiSourceConfig, type OpenApiExportConfig, type OpenApiConfig, type FolderConventions, type ContractsrcConfig, type SchemaFormat, type FormatterType, type FormatterConfig, type BumpStrategy, type ChangelogFormat, type ChangelogTier, type VersioningConfig, type RuleSyncTarget, type RuleSyncConfig, type ContractsrcFileConfig, type ResolvedContractsrcConfig, } from './contractsrc-schema';