@fission-ai/openspec 0.21.0 → 0.22.0

package/dist/core/config-prompts.js

@@ -0,0 +1,151 @@
+import { stringify as stringifyYaml } from 'yaml';
+import { listSchemasWithInfo, resolveSchema } from './artifact-graph/resolver.js';
+/**
+ * Check if an error is an ExitPromptError (user cancelled with Ctrl+C).
+ * Used instead of instanceof check since @inquirer modules use dynamic imports.
+ */
+export function isExitPromptError(error) {
+    return (error !== null &&
+        typeof error === 'object' &&
+        'name' in error &&
+        error.name === 'ExitPromptError');
+}
+/**
+ * Prompt user to create project config interactively.
+ * Used by experimental setup command.
+ *
+ * @param projectRoot - Optional project root for project-local schema resolution
+ * @returns Config prompt result
+ * @throws ExitPromptError if user cancels (Ctrl+C)
+ */
+export async function promptForConfig(projectRoot) {
+    // Dynamic imports to prevent pre-commit hook hangs (see #367)
+    const { confirm, select, editor, checkbox } = await import('@inquirer/prompts');
+    // Ask if user wants to create config
+    const shouldCreate = await confirm({
+        message: 'Create openspec/config.yaml?',
+        default: true,
+    });
+    if (!shouldCreate) {
+        return { createConfig: false };
+    }
+    // Get available schemas
+    const schemas = listSchemasWithInfo(projectRoot);
+    if (schemas.length === 0) {
+        throw new Error('No schemas found. Cannot create config.');
+    }
+    // Prompt for schema selection
+    const selectedSchema = await select({
+        message: 'Default schema for new changes?',
+        choices: schemas.map((s) => ({
+            name: `${s.name} (${s.artifacts.join(' → ')})`,
+            value: s.name,
+            description: s.description || undefined,
+        })),
+    });
+    // Prompt for project context
+    console.log('\nAdd project context? (optional)');
+    console.log('Context is shown to AI when creating artifacts.');
+    console.log('Examples: tech stack, conventions, style guides, domain knowledge\n');
+    const contextInput = await editor({
+        message: 'Press Enter to skip, or edit context:',
+        default: '',
+        waitForUseInput: false,
+    });
+    const context = contextInput.trim() || undefined;
+    // Prompt for per-artifact rules
+    const addRules = await confirm({
+        message: 'Add per-artifact rules? (optional)',
+        default: false,
+    });
+    let rules;
+    if (addRules) {
+        // Load the selected schema to get artifact list
+        const schema = resolveSchema(selectedSchema, projectRoot);
+        const artifactIds = schema.artifacts.map((a) => a.id);
+        // Let user select which artifacts to add rules for
+        const selectedArtifacts = await checkbox({
+            message: 'Which artifacts should have custom rules?',
+            choices: artifactIds.map((id) => ({
+                name: id,
+                value: id,
+            })),
+        });
+        if (selectedArtifacts.length > 0) {
+            rules = {};
+            // For each selected artifact, collect rules line by line
+            for (const artifactId of selectedArtifacts) {
+                const artifactRules = await promptForArtifactRules(artifactId);
+                if (artifactRules.length > 0) {
+                    rules[artifactId] = artifactRules;
+                }
+            }
+            // If no rules were actually added, set to undefined
+            if (Object.keys(rules).length === 0) {
+                rules = undefined;
+            }
+        }
+    }
+    return {
+        createConfig: true,
+        schema: selectedSchema,
+        context,
+        rules,
+    };
+}
+/**
+ * Prompt for rules for a specific artifact.
+ * Collects rules one per line until user enters empty line.
+ *
+ * @param artifactId - The artifact ID to collect rules for
+ * @returns Array of rules
+ */
+async function promptForArtifactRules(artifactId) {
+    // Dynamic import to prevent pre-commit hook hangs (see #367)
+    const { input } = await import('@inquirer/prompts');
+    const rules = [];
+    console.log(`\nRules for ${artifactId} artifact:`);
+    console.log('Enter rules one per line, press Enter on empty line to finish:\n');
+    while (true) {
+        const rule = await input({
+            message: '│',
+            validate: () => {
+                // Empty string is valid (signals end of input)
+                return true;
+            },
+        });
+        const trimmed = rule.trim();
+        // Empty line signals end of input
+        if (!trimmed) {
+            break;
+        }
+        rules.push(trimmed);
+    }
+    return rules;
+}
+/**
+ * Serialize config to YAML string with proper multi-line formatting.
+ *
+ * @param config - Partial config object (schema required, context/rules optional)
+ * @returns YAML string ready to write to file
+ */
+export function serializeConfig(config) {
+    // Build clean config object (only include defined fields)
+    const cleanConfig = {
+        schema: config.schema,
+    };
+    if (config.context) {
+        cleanConfig.context = config.context;
+    }
+    if (config.rules && Object.keys(config.rules).length > 0) {
+        cleanConfig.rules = config.rules;
+    }
+    // Serialize to YAML with proper formatting
+    return stringifyYaml(cleanConfig, {
+        indent: 2,
+        lineWidth: 0, // Don't wrap long lines
+        defaultStringType: 'PLAIN',
+        defaultKeyType: 'PLAIN',
+    });
+}
+//# sourceMappingURL=config-prompts.js.map

package/dist/core/project-config.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+/**
+ * Zod schema for project configuration.
+ *
+ * Purpose:
+ * 1. Documentation - clearly defines the config file structure
+ * 2. Type safety - TypeScript infers ProjectConfig type from schema
+ * 3. Runtime validation - uses safeParse() for resilient field-by-field validation
+ *
+ * Why Zod over manual validation:
+ * - Helps understand OpenSpec's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other OpenSpec schemas
+ */
+export declare const ProjectConfigSchema: z.ZodObject<{
+    schema: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+/**
+ * Read and parse openspec/config.yaml from project root.
+ * Uses resilient parsing - validates each field independently using Zod safeParse.
+ * Returns null if file doesn't exist.
+ * Returns partial config if some fields are invalid (with warnings).
+ *
+ * Performance note (Jan 2025):
+ * Benchmarks showed direct file reads are fast enough without caching:
+ * - Typical config (1KB): ~0.5ms per read
+ * - Large config (50KB): ~1.6ms per read
+ * - Missing config: ~0.01ms per read
+ * Config is read 1-2 times per command (schema resolution + instruction loading),
+ * adding ~1-3ms total overhead. Caching would add complexity (mtime checks,
+ * invalidation logic) for negligible benefit. Direct reads also ensure config
+ * changes are reflected immediately without stale cache issues.
+ *
+ * @param projectRoot - The root directory of the project (where `openspec/` lives)
+ * @returns Parsed config or null if file doesn't exist
+ */
+export declare function readProjectConfig(projectRoot: string): ProjectConfig | null;
+/**
+ * Validate artifact IDs in rules against a schema's artifacts.
+ * Called during instruction loading (when schema is known).
+ * Returns warnings for unknown artifact IDs.
+ *
+ * @param rules - The rules object from config
+ * @param validArtifactIds - Set of valid artifact IDs from the schema
+ * @param schemaName - Name of the schema for error messages
+ * @returns Array of warning messages for unknown artifact IDs
+ */
+export declare function validateConfigRules(rules: Record<string, string[]>, validArtifactIds: Set<string>, schemaName: string): string[];
+/**
+ * Suggest valid schema names when user provides invalid schema.
+ * Uses fuzzy matching to find similar names.
+ *
+ * @param invalidSchemaName - The invalid schema name from config
+ * @param availableSchemas - List of available schemas with their type (built-in or project-local)
+ * @returns Error message with suggestions and available schemas
+ */
+export declare function suggestSchemas(invalidSchemaName: string, availableSchemas: {
+    name: string;
+    isBuiltIn: boolean;
+}[]): string;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/core/project-config.js

@@ -0,0 +1,223 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+/**
+ * Zod schema for project configuration.
+ *
+ * Purpose:
+ * 1. Documentation - clearly defines the config file structure
+ * 2. Type safety - TypeScript infers ProjectConfig type from schema
+ * 3. Runtime validation - uses safeParse() for resilient field-by-field validation
+ *
+ * Why Zod over manual validation:
+ * - Helps understand OpenSpec's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other OpenSpec schemas
+ */
+export const ProjectConfigSchema = z.object({
+    // Required: which schema to use (e.g., "spec-driven", "tdd", or project-local schema name)
+    schema: z
+        .string()
+        .min(1)
+        .describe('The workflow schema to use (e.g., "spec-driven", "tdd")'),
+    // Optional: project context (injected into all artifact instructions)
+    // Max size: 50KB (enforced during parsing)
+    context: z
+        .string()
+        .optional()
+        .describe('Project context injected into all artifact instructions'),
+    // Optional: per-artifact rules (additive to schema's built-in guidance)
+    rules: z
+        .record(z.string(), // artifact ID
+    z.array(z.string()) // list of rules
+    )
+        .optional()
+        .describe('Per-artifact rules, keyed by artifact ID'),
+});
+const MAX_CONTEXT_SIZE = 50 * 1024; // 50KB hard limit
+/**
+ * Read and parse openspec/config.yaml from project root.
+ * Uses resilient parsing - validates each field independently using Zod safeParse.
+ * Returns null if file doesn't exist.
+ * Returns partial config if some fields are invalid (with warnings).
+ *
+ * Performance note (Jan 2025):
+ * Benchmarks showed direct file reads are fast enough without caching:
+ * - Typical config (1KB): ~0.5ms per read
+ * - Large config (50KB): ~1.6ms per read
+ * - Missing config: ~0.01ms per read
+ * Config is read 1-2 times per command (schema resolution + instruction loading),
+ * adding ~1-3ms total overhead. Caching would add complexity (mtime checks,
+ * invalidation logic) for negligible benefit. Direct reads also ensure config
+ * changes are reflected immediately without stale cache issues.
+ *
+ * @param projectRoot - The root directory of the project (where `openspec/` lives)
+ * @returns Parsed config or null if file doesn't exist
+ */
+export function readProjectConfig(projectRoot) {
+    // Try both .yaml and .yml, prefer .yaml
+    let configPath = path.join(projectRoot, 'openspec', 'config.yaml');
+    if (!existsSync(configPath)) {
+        configPath = path.join(projectRoot, 'openspec', 'config.yml');
+        if (!existsSync(configPath)) {
+            return null; // No config is OK
+        }
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const raw = parseYaml(content);
+        if (!raw || typeof raw !== 'object') {
+            console.warn(`openspec/config.yaml is not a valid YAML object`);
+            return null;
+        }
+        const config = {};
+        // Parse schema field using Zod
+        const schemaField = z.string().min(1);
+        const schemaResult = schemaField.safeParse(raw.schema);
+        if (schemaResult.success) {
+            config.schema = schemaResult.data;
+        }
+        else if (raw.schema !== undefined) {
+            console.warn(`Invalid 'schema' field in config (must be non-empty string)`);
+        }
+        // Parse context field with size limit
+        if (raw.context !== undefined) {
+            const contextField = z.string();
+            const contextResult = contextField.safeParse(raw.context);
+            if (contextResult.success) {
+                const contextSize = Buffer.byteLength(contextResult.data, 'utf-8');
+                if (contextSize > MAX_CONTEXT_SIZE) {
+                    console.warn(`Context too large (${(contextSize / 1024).toFixed(1)}KB, limit: ${MAX_CONTEXT_SIZE / 1024}KB)`);
+                    console.warn(`Ignoring context field`);
+                }
+                else {
+                    config.context = contextResult.data;
+                }
+            }
+            else {
+                console.warn(`Invalid 'context' field in config (must be string)`);
+            }
+        }
+        // Parse rules field using Zod
+        if (raw.rules !== undefined) {
+            const rulesField = z.record(z.string(), z.array(z.string()));
+            // First check if it's an object structure (guard against null since typeof null === 'object')
+            if (typeof raw.rules === 'object' && raw.rules !== null && !Array.isArray(raw.rules)) {
+                const parsedRules = {};
+                let hasValidRules = false;
+                for (const [artifactId, rules] of Object.entries(raw.rules)) {
+                    const rulesArrayResult = z.array(z.string()).safeParse(rules);
+                    if (rulesArrayResult.success) {
+                        // Filter out empty strings
+                        const validRules = rulesArrayResult.data.filter((r) => r.length > 0);
+                        if (validRules.length > 0) {
+                            parsedRules[artifactId] = validRules;
+                            hasValidRules = true;
+                        }
+                        if (validRules.length < rulesArrayResult.data.length) {
+                            console.warn(`Some rules for '${artifactId}' are empty strings, ignoring them`);
+                        }
+                    }
+                    else {
+                        console.warn(`Rules for '${artifactId}' must be an array of strings, ignoring this artifact's rules`);
+                    }
+                }
+                if (hasValidRules) {
+                    config.rules = parsedRules;
+                }
+            }
+            else {
+                console.warn(`Invalid 'rules' field in config (must be object)`);
+            }
+        }
+        // Return partial config even if some fields failed
+        return Object.keys(config).length > 0 ? config : null;
+    }
+    catch (error) {
+        console.warn(`Failed to parse openspec/config.yaml:`, error);
+        return null;
+    }
+}
+/**
+ * Validate artifact IDs in rules against a schema's artifacts.
+ * Called during instruction loading (when schema is known).
+ * Returns warnings for unknown artifact IDs.
+ *
+ * @param rules - The rules object from config
+ * @param validArtifactIds - Set of valid artifact IDs from the schema
+ * @param schemaName - Name of the schema for error messages
+ * @returns Array of warning messages for unknown artifact IDs
+ */
+export function validateConfigRules(rules, validArtifactIds, schemaName) {
+    const warnings = [];
+    for (const artifactId of Object.keys(rules)) {
+        if (!validArtifactIds.has(artifactId)) {
+            const validIds = Array.from(validArtifactIds).sort().join(', ');
+            warnings.push(`Unknown artifact ID in rules: "${artifactId}". ` +
+                `Valid IDs for schema "${schemaName}": ${validIds}`);
+        }
+    }
+    return warnings;
+}
+/**
+ * Suggest valid schema names when user provides invalid schema.
+ * Uses fuzzy matching to find similar names.
+ *
+ * @param invalidSchemaName - The invalid schema name from config
+ * @param availableSchemas - List of available schemas with their type (built-in or project-local)
+ * @returns Error message with suggestions and available schemas
+ */
+export function suggestSchemas(invalidSchemaName, availableSchemas) {
+    // Simple fuzzy match: Levenshtein distance
+    function levenshtein(a, b) {
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    // Find closest matches (distance <= 3)
+    const suggestions = availableSchemas
+        .map((s) => ({ ...s, distance: levenshtein(invalidSchemaName, s.name) }))
+        .filter((s) => s.distance <= 3)
+        .sort((a, b) => a.distance - b.distance)
+        .slice(0, 3);
+    const builtIn = availableSchemas.filter((s) => s.isBuiltIn).map((s) => s.name);
+    const projectLocal = availableSchemas.filter((s) => !s.isBuiltIn).map((s) => s.name);
+    let message = `Schema '${invalidSchemaName}' not found in openspec/config.yaml\n\n`;
+    if (suggestions.length > 0) {
+        message += `Did you mean one of these?\n`;
+        suggestions.forEach((s) => {
+            const type = s.isBuiltIn ? 'built-in' : 'project-local';
+            message += `  - ${s.name} (${type})\n`;
+        });
+        message += '\n';
+    }
+    message += `Available schemas:\n`;
+    if (builtIn.length > 0) {
+        message += `  Built-in: ${builtIn.join(', ')}\n`;
+    }
+    if (projectLocal.length > 0) {
+        message += `  Project-local: ${projectLocal.join(', ')}\n`;
+    }
+    else {
+        message += `  Project-local: (none found)\n`;
+    }
+    message += `\nFix: Edit openspec/config.yaml and change 'schema: ${invalidSchemaName}' to a valid schema name`;
+    return message;
+}
+//# sourceMappingURL=project-config.js.map

package/dist/utils/change-metadata.d.ts

@@ -11,33 +11,37 @@ export declare class ChangeMetadataError extends Error {
  * Validates that a schema name is valid (exists in available schemas).
  *
  * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @returns The validated schema name
  * @throws Error if schema is not found
  */
-export declare function validateSchemaName(schemaName: string): string;
+export declare function validateSchemaName(schemaName: string, projectRoot?: string): string;
 /**
  * Writes change metadata to .openspec.yaml in the change directory.
  *
  * @param changeDir - The path to the change directory
  * @param metadata - The metadata to write
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @throws ChangeMetadataError if validation fails or write fails
  */
-export declare function writeChangeMetadata(changeDir: string, metadata: ChangeMetadata): void;
+export declare function writeChangeMetadata(changeDir: string, metadata: ChangeMetadata, projectRoot?: string): void;
 /**
  * Reads change metadata from .openspec.yaml in the change directory.
  *
  * @param changeDir - The path to the change directory
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @returns The validated metadata, or null if no metadata file exists
  * @throws ChangeMetadataError if the file exists but is invalid
  */
-export declare function readChangeMetadata(changeDir: string): ChangeMetadata | null;
+export declare function readChangeMetadata(changeDir: string, projectRoot?: string): ChangeMetadata | null;
 /**
  * Resolves the schema for a change, with explicit override taking precedence.
  *
  * Resolution order:
  * 1. Explicit schema (if provided)
  * 2. Schema from .openspec.yaml metadata (if exists)
- * 3. Default 'spec-driven'
+ * 3. Schema from openspec/config.yaml (if exists)
+ * 4. Default 'spec-driven'
  *
  * @param changeDir - The path to the change directory
  * @param explicitSchema - Optional explicit schema override

package/dist/utils/change-metadata.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import * as yaml from 'yaml';
 import { ChangeMetadataSchema } from '../core/artifact-graph/types.js';
 import { listSchemas } from '../core/artifact-graph/resolver.js';
+import { readProjectConfig } from '../core/project-config.js';
 const METADATA_FILENAME = '.openspec.yaml';
 /**
  * Error thrown when change metadata validation fails.
@@ -21,11 +22,12 @@ export class ChangeMetadataError extends Error {
  * Validates that a schema name is valid (exists in available schemas).
  *
  * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @returns The validated schema name
  * @throws Error if schema is not found
  */
-export function validateSchemaName(schemaName) {
-    const availableSchemas = listSchemas();
+export function validateSchemaName(schemaName, projectRoot) {
+    const availableSchemas = listSchemas(projectRoot);
     if (!availableSchemas.includes(schemaName)) {
         throw new Error(`Unknown schema '${schemaName}'. Available: ${availableSchemas.join(', ')}`);
     }
@@ -36,12 +38,13 @@ export function validateSchemaName(schemaName) {
  *
  * @param changeDir - The path to the change directory
  * @param metadata - The metadata to write
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @throws ChangeMetadataError if validation fails or write fails
  */
-export function writeChangeMetadata(changeDir, metadata) {
+export function writeChangeMetadata(changeDir, metadata, projectRoot) {
     const metaPath = path.join(changeDir, METADATA_FILENAME);
     // Validate schema exists
-    validateSchemaName(metadata.schema);
+    validateSchemaName(metadata.schema, projectRoot);
     // Validate with Zod
     const parseResult = ChangeMetadataSchema.safeParse(metadata);
     if (!parseResult.success) {
@@ -61,10 +64,11 @@ export function writeChangeMetadata(changeDir, metadata) {
  * Reads change metadata from .openspec.yaml in the change directory.
  *
  * @param changeDir - The path to the change directory
+ * @param projectRoot - Optional project root for project-local schema resolution
  * @returns The validated metadata, or null if no metadata file exists
  * @throws ChangeMetadataError if the file exists but is invalid
  */
-export function readChangeMetadata(changeDir) {
+export function readChangeMetadata(changeDir, projectRoot) {
     const metaPath = path.join(changeDir, METADATA_FILENAME);
     if (!fs.existsSync(metaPath)) {
         return null;
@@ -91,7 +95,7 @@ export function readChangeMetadata(changeDir) {
         throw new ChangeMetadataError(`Invalid metadata: ${parseResult.error.message}`, metaPath);
     }
     // Validate that the schema exists
-    const availableSchemas = listSchemas();
+    const availableSchemas = listSchemas(projectRoot);
     if (!availableSchemas.includes(parseResult.data.schema)) {
         throw new ChangeMetadataError(`Unknown schema '${parseResult.data.schema}'. Available: ${availableSchemas.join(', ')}`, metaPath);
     }
@@ -103,28 +107,41 @@ export function readChangeMetadata(changeDir) {
  * Resolution order:
  * 1. Explicit schema (if provided)
  * 2. Schema from .openspec.yaml metadata (if exists)
- * 3. Default 'spec-driven'
+ * 3. Schema from openspec/config.yaml (if exists)
+ * 4. Default 'spec-driven'
  *
  * @param changeDir - The path to the change directory
  * @param explicitSchema - Optional explicit schema override
  * @returns The resolved schema name
  */
 export function resolveSchemaForChange(changeDir, explicitSchema) {
+    // Derive project root from changeDir (changeDir is typically projectRoot/openspec/changes/change-name)
+    const projectRoot = path.resolve(changeDir, '../../..');
     // 1. Explicit override wins
     if (explicitSchema) {
         return explicitSchema;
     }
     // 2. Try reading from metadata
     try {
-        const metadata = readChangeMetadata(changeDir);
+        const metadata = readChangeMetadata(changeDir, projectRoot);
         if (metadata?.schema) {
             return metadata.schema;
         }
     }
     catch {
-        // If metadata read fails, fall back to default
+        // If metadata read fails, continue to next option
     }
-    // 3. Default
+    // 3. Try reading from project config
+    try {
+        const config = readProjectConfig(projectRoot);
+        if (config?.schema) {
+            return config.schema;
+        }
+    }
+    catch {
+        // If config read fails, fall back to default
+    }
+    // 4. Default
     return 'spec-driven';
 }
 //# sourceMappingURL=change-metadata.js.map

package/dist/utils/change-utils.d.ts

@@ -5,6 +5,13 @@ export interface CreateChangeOptions {
     /** The workflow schema to use (default: 'spec-driven') */
     schema?: string;
 }
+/**
+ * Result of creating a change.
+ */
+export interface CreateChangeResult {
+    /** The schema that was actually used (resolved from options, config, or default) */
+    schema: string;
+}
 /**
  * Result of validating a change name.
  */
@@ -39,13 +46,17 @@ export declare function validateChangeName(name: string): ValidationResult;
  * @throws Error if the schema name is invalid
  * @throws Error if the change directory already exists
  *
+ * @returns Result containing the resolved schema name
+ *
  * @example
  * // Creates openspec/changes/add-auth/ with default schema
- * await createChange('/path/to/project', 'add-auth')
+ * const result = await createChange('/path/to/project', 'add-auth')
+ * console.log(result.schema) // 'spec-driven' or value from config
  *
  * @example
  * // Creates openspec/changes/add-auth/ with TDD schema
- * await createChange('/path/to/project', 'add-auth', { schema: 'tdd' })
+ * const result = await createChange('/path/to/project', 'add-auth', { schema: 'tdd' })
+ * console.log(result.schema) // 'tdd'
  */
-export declare function createChange(projectRoot: string, name: string, options?: CreateChangeOptions): Promise<void>;
+export declare function createChange(projectRoot: string, name: string, options?: CreateChangeOptions): Promise<CreateChangeResult>;
 //# sourceMappingURL=change-utils.d.ts.map