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

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.0.0-canary-20251221164004
+## 0.0.0-canary-20251221185840
 
 ### Minor Changes
 
@@ -9,14 +9,14 @@
 ### Patch Changes
 
 - Updated dependencies [66a5dfd]
-  - @lssm/bundle.contractspec-workspace@0.0.0-canary-20251221164004
-  - @lssm/lib.ai-providers@0.0.0-canary-20251221164004
-  - @lssm/lib.contracts@0.0.0-canary-20251221164004
-  - @lssm/lib.contracts-transformers@0.0.0-canary-20251221164004
-  - @lssm/lib.schema@0.0.0-canary-20251221164004
-  - @lssm/lib.testing@0.0.0-canary-20251221164004
-  - @lssm/module.ai-chat@0.0.0-canary-20251221164004
-  - @lssm/module.contractspec-examples@0.0.0-canary-20251221164004
+  - @lssm/bundle.contractspec-workspace@0.0.0-canary-20251221185840
+  - @lssm/lib.ai-providers@0.0.0-canary-20251221185840
+  - @lssm/lib.contracts@0.0.0-canary-20251221185840
+  - @lssm/lib.contracts-transformers@0.0.0-canary-20251221185840
+  - @lssm/lib.schema@0.0.0-canary-20251221185840
+  - @lssm/lib.testing@0.0.0-canary-20251221185840
+  - @lssm/module.ai-chat@0.0.0-canary-20251221185840
+  - @lssm/module.contractspec-examples@0.0.0-canary-20251221185840
 
 ## 0.12.0
 

package/dist/ai/agents/claude-code-agent.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Claude Code Agent - Uses Anthropic's advanced code capabilities
+ * with extended context and agentic workflows
+ */
+import type { AgentProvider, AgentResult, AgentTask } from './types';
+export declare class ClaudeCodeAgent implements AgentProvider {
+    name: "claude-code";
+    private apiKey;
+    constructor();
+    canHandle(_task: AgentTask): boolean;
+    generate(task: AgentTask): Promise<AgentResult>;
+    validate(task: AgentTask): Promise<AgentResult>;
+    private buildSystemPrompt;
+    private buildUserPrompt;
+    private extractCode;
+    private detectIssues;
+    private extractErrors;
+    private extractWarnings;
+    private extractSuggestions;
+}
+//# sourceMappingURL=claude-code-agent.d.ts.map

package/dist/ai/agents/cursor-agent.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Cursor/Windsurf Agent - Fully Implemented
+ * Leverages Windsurf AI capabilities and Cursor IDE integration for code generation and validation
+ */
+import type { AgentProvider, AgentResult, AgentTask } from './types';
+export declare class CursorAgent implements AgentProvider {
+    name: "cursor";
+    private cursorPath;
+    private isWindsurf;
+    private composerPort;
+    constructor();
+    canHandle(_task: AgentTask): boolean;
+    generate(task: AgentTask): Promise<AgentResult>;
+    validate(task: AgentTask): Promise<AgentResult>;
+    /**
+     * Detect if running in Cursor/Windsurf environment
+     */
+    private detectEnvironment;
+    /**
+     * Execute task using the best available method
+     */
+    private executeWithBestMethod;
+    /**
+     * Use Windsurf's native API
+     */
+    /**
+     * Use Cursor Composer API
+     */
+    /**
+     * Use Cursor CLI directly
+     */
+    private useCursorCLI;
+    /**
+     * File-based approach - create workspace and instructions for manual completion
+     */
+    private useFileBasedApproach;
+    /**
+     * Setup workspace for validation
+     */
+    private setupValidationWorkspace;
+    /**
+     * Prepare files for API submission
+     */
+    private prepareFilesForAPI;
+    /**
+     * Build detailed prompt for cursor
+     */
+    private buildDetailedPrompt;
+    /**
+     * Build validation-specific prompt
+     */
+    private buildValidationPrompt;
+    /**
+     * Generate basic template for task
+     */
+    private generateTemplate;
+    /**
+     * Cleanup temporary work directory
+     */
+    private cleanupWorkDir;
+    private isCursorAvailable;
+    /**
+     * Check if Cursor Composer API might be available
+     */
+    private hasComposerAPI;
+}
+//# sourceMappingURL=cursor-agent.d.ts.map

package/dist/ai/agents/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agent system exports
+ */
+export { AgentOrchestrator } from './orchestrator';
+export { SimpleAgent } from './simple-agent';
+export { CursorAgent } from './cursor-agent';
+export { ClaudeCodeAgent } from './claude-code-agent';
+export { OpenAICodexAgent } from './openai-codex-agent';
+export type { AgentMode, AgentTask, AgentResult, AgentProvider, AgentConfig, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/ai/agents/openai-codex-agent.d.ts

@@ -0,0 +1,21 @@
+/**
+ * OpenAI Codex Agent - Uses OpenAI's code-optimized models
+ * Supports GPT-4o and o1 reasoning models for complex code generation
+ */
+import type { AgentProvider, AgentResult, AgentTask } from './types';
+export declare class OpenAICodexAgent implements AgentProvider {
+    name: "openai-codex";
+    private apiKey;
+    constructor();
+    canHandle(_task: AgentTask): boolean;
+    generate(task: AgentTask): Promise<AgentResult>;
+    validate(task: AgentTask): Promise<AgentResult>;
+    private isComplexTask;
+    private buildSystemPrompt;
+    private buildUserPrompt;
+    private extractCode;
+    private detectIssues;
+    private extractErrors;
+    private extractWarnings;
+}
+//# sourceMappingURL=openai-codex-agent.d.ts.map

package/dist/ai/agents/orchestrator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Agent Orchestrator - Coordinates between different AI agents
+ * Selects the appropriate agent based on config and task requirements
+ */
+import type { Config } from '../../utils/config';
+import type { AgentMode, AgentResult, AgentTask } from './types';
+export declare class AgentOrchestrator {
+    private config;
+    private agents;
+    private defaultAgent;
+    constructor(config: Config);
+    /**
+     * Execute a task using the configured agent with fallback support
+     */
+    executeTask(task: AgentTask): Promise<AgentResult>;
+    /**
+     * Generate code from specification
+     */
+    generate(specCode: string, targetPath?: string): Promise<AgentResult>;
+    /**
+     * Generate tests for implementation
+     */
+    generateTests(specCode: string, implementationCode: string): Promise<AgentResult>;
+    /**
+     * Validate implementation against specification
+     */
+    validate(specCode: string, implementationCode: string): Promise<AgentResult>;
+    /**
+     * Refactor existing code
+     */
+    refactor(specCode: string, existingCode: string): Promise<AgentResult>;
+    /**
+     * List available agents and their status
+     */
+    getAvailableAgents(): Promise<{
+        mode: AgentMode;
+        available: boolean;
+        reason?: string;
+    }[]>;
+    /**
+     * Get the configured agent mode
+     */
+    private getAgentMode;
+    /**
+     * Get fallback mode for an agent
+     */
+    private getFallbackMode;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/ai/agents/simple-agent.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Simple LLM-based agent using direct API calls
+ * This is the default fallback for basic code generation
+ */
+import type { Config } from '../../utils/config';
+import type { AgentProvider, AgentResult, AgentTask } from './types';
+export declare class SimpleAgent implements AgentProvider {
+    private config;
+    name: "simple";
+    constructor(config: Config);
+    canHandle(_task: AgentTask): boolean;
+    generate(task: AgentTask): Promise<AgentResult>;
+    validate(task: AgentTask): Promise<AgentResult>;
+    private buildPrompt;
+}
+//# sourceMappingURL=simple-agent.d.ts.map

package/dist/ai/agents/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent types and interfaces for code generation and validation
+ */
+export type AgentMode = 'simple' | 'cursor' | 'claude-code' | 'openai-codex';
+export interface AgentTask {
+    type: 'generate' | 'validate' | 'refactor' | 'test';
+    specCode: string;
+    existingCode?: string;
+    targetPath?: string;
+    options?: Record<string, unknown>;
+}
+export interface AgentResult {
+    success: boolean;
+    code?: string;
+    errors?: string[];
+    warnings?: string[];
+    suggestions?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface AgentProvider {
+    name: AgentMode;
+    generate(task: AgentTask): Promise<AgentResult>;
+    validate(task: AgentTask): Promise<AgentResult>;
+    canHandle(task: AgentTask): boolean;
+}
+export interface AgentConfig {
+    mode: AgentMode;
+    fallbackMode?: AgentMode;
+    timeout?: number;
+    retries?: number;
+    options?: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ai/client.d.ts

@@ -0,0 +1,78 @@
+import type { Config } from '../utils/config';
+import type { OpKind, PresentationKind } from '../types';
+/**
+ * AI Client for spec creation and code generation
+ */
+export declare class AIClient {
+    private config;
+    constructor(config: Config);
+    /**
+     * Generate operation spec from natural language description
+     */
+    generateOperationSpec(description: string, kind: OpKind): Promise<{
+        name: string;
+        version: number;
+        description: string;
+        goal: string;
+        context: string;
+        stability: "experimental" | "beta" | "stable" | "deprecated";
+        owners: string[];
+        tags: string[];
+        auth: "user" | "anonymous" | "admin";
+        inputShape: string;
+        outputShape: string;
+        flags: string[];
+        possibleEvents: string[];
+        analytics: string[];
+    }>;
+    /**
+     * Generate event spec from description
+     */
+    generateEventSpec(description: string): Promise<{
+        name: string;
+        version: number;
+        description: string;
+        stability: "experimental" | "beta" | "stable" | "deprecated";
+        owners: string[];
+        tags: string[];
+        payloadShape: string;
+        piiFields: string[];
+    }>;
+    /**
+     * Generate presentation spec from description
+     */
+    generatePresentationSpec(description: string, kind: PresentationKind): Promise<{
+        name: string;
+        version: number;
+        description: string;
+        stability: "experimental" | "beta" | "stable" | "deprecated";
+        owners: string[];
+        tags: string[];
+        componentKey?: string | undefined;
+        propsShape?: string | undefined;
+        content?: string | undefined;
+        mimeType?: string | undefined;
+        dataShape?: string | undefined;
+    }>;
+    /**
+     * Generate handler implementation from spec
+     */
+    generateHandler(specCode: string): Promise<string>;
+    /**
+     * Generate React component from presentation spec
+     */
+    generateComponent(specCode: string): Promise<string>;
+    /**
+     * Generate form component from form spec
+     */
+    generateForm(specCode: string): Promise<string>;
+    /**
+     * Generate tests for implementation
+     */
+    generateTests(specCode: string, implementationCode: string, testType: 'handler' | 'component'): Promise<string>;
+    /**
+     * Stream code generation for better UX
+     */
+    streamCodeGeneration(prompt: string, onChunk: (text: string) => void): Promise<string>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/ai/prompts/code-generation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build prompt for generating handler implementation
+ */
+export declare function buildHandlerPrompt(specCode: string): string;
+/**
+ * Build prompt for generating React component from presentation spec
+ */
+export declare function buildComponentPrompt(specCode: string): string;
+/**
+ * Build prompt for generating form component
+ */
+export declare function buildFormPrompt(specCode: string): string;
+/**
+ * Build prompt for generating tests
+ */
+export declare function buildTestPrompt(specCode: string, implementationCode: string, testType: 'handler' | 'component'): string;
+/**
+ * System prompt for code generation
+ */
+export declare function getCodeGenSystemPrompt(): string;
+//# sourceMappingURL=code-generation.d.ts.map

package/dist/ai/prompts/spec-creation.d.ts

@@ -0,0 +1,22 @@
+import type { OpKind, PresentationKind } from '../../types';
+/**
+ * Build prompt for creating operation spec from description
+ */
+export declare function buildOperationSpecPrompt(description: string, kind: OpKind): string;
+/**
+ * Build prompt for creating event spec from description
+ */
+export declare function buildEventSpecPrompt(description: string): string;
+/**
+ * Build prompt for creating presentation spec from description
+ */
+export declare function buildPresentationSpecPrompt(description: string, kind: PresentationKind): string;
+/**
+ * Build system prompt for all spec generation
+ */
+export declare function getSystemPrompt(): string;
+/**
+ * Create example-based prompt for better results
+ */
+export declare function addExampleContext(basePrompt: string, examples: string[]): string;
+//# sourceMappingURL=spec-creation.d.ts.map

package/dist/ai/providers.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageModel } from 'ai';
+import type { Config } from '../utils/config';
+/**
+ * Initialize AI provider based on configuration
+ */
+export declare function getAIProvider(config: Config): LanguageModel;
+/**
+ * Validate that the provider is accessible and working
+ */
+export declare function validateProvider(config: Config): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Get recommended models for each provider
+ */
+export declare function getRecommendedModels(provider: Config['aiProvider']): string[];
+//# sourceMappingURL=providers.d.ts.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/commands/build/agent-generation.d.ts

@@ -0,0 +1,23 @@
+import type { AgentOrchestrator } from '../../ai/agents/index';
+import type { AgentResult } from '../../ai/agents/types';
+import type { GenerationTarget, TestTarget } from './types';
+export declare function generateWithAgent(orchestrator: AgentOrchestrator | null, agentMode: string, task: {
+    label: string;
+    target: GenerationTarget;
+    specCode: string;
+    targetPath?: string;
+}): Promise<{
+    code: string;
+    result: AgentResult;
+} | null>;
+export declare function generateTestsWithAgent(orchestrator: AgentOrchestrator | null, agentMode: string, task: {
+    specCode: string;
+    existingCode: string;
+    target: TestTarget;
+}): Promise<{
+    code: string;
+    result: AgentResult;
+} | null>;
+export declare function stripCode(text: string): string;
+export declare function ensureTrailingNewline(code: string): string;
+//# sourceMappingURL=agent-generation.d.ts.map

package/dist/commands/build/build-command.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildCommand(specFile: string, options: BuildOptions, config: Config): Promise<void>;
+//# sourceMappingURL=build-command.d.ts.map

package/dist/commands/build/build-data-view.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildDataView(specFile: string, specCode: string, options: BuildOptions, config: Config): Promise<void>;
+//# sourceMappingURL=build-data-view.d.ts.map

package/dist/commands/build/build-form.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOrchestrator } from '../../ai/agents/index';
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildForm(specFile: string, specCode: string, options: BuildOptions, config: Config, orchestrator: AgentOrchestrator | null): Promise<void>;
+//# sourceMappingURL=build-form.d.ts.map

package/dist/commands/build/build-operation.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOrchestrator } from '../../ai/agents/index';
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildOperation(specFile: string, specCode: string, options: BuildOptions, config: Config, orchestrator: AgentOrchestrator | null): Promise<void>;
+//# sourceMappingURL=build-operation.d.ts.map

package/dist/commands/build/build-presentation.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOrchestrator } from '../../ai/agents/index';
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildPresentation(specFile: string, specCode: string, options: BuildOptions, config: Config, orchestrator: AgentOrchestrator | null): Promise<void>;
+//# sourceMappingURL=build-presentation.d.ts.map

package/dist/commands/build/build-workflow.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function buildWorkflow(specFile: string, specCode: string, options: BuildOptions, config: Config): Promise<void>;
+//# sourceMappingURL=build-workflow.d.ts.map

package/dist/commands/build/data-view-renderer-template.d.ts

@@ -0,0 +1,7 @@
+export declare function generateDataViewRendererTemplate({ exportName, specImportPath, rendererName, viewKind, }: {
+    exportName: string;
+    specImportPath: string;
+    rendererName: string;
+    viewKind: string;
+}): string;
+//# sourceMappingURL=data-view-renderer-template.d.ts.map

package/dist/commands/build/index.d.ts

@@ -0,0 +1,10 @@
+import { buildCommand } from './build-command';
+import { detectSpecType } from './spec-detect';
+import { ensureTrailingNewline, stripCode } from './agent-generation';
+export { buildCommand };
+export declare const __buildInternals: {
+    detectSpecType: typeof detectSpecType;
+    stripCode: typeof stripCode;
+    ensureTrailingNewline: typeof ensureTrailingNewline;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/build/index.test.d.ts

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

package/dist/commands/build/naming.d.ts

@@ -0,0 +1,3 @@
+export declare function toKebabCase(str: string): string;
+export declare function toPascalCase(str: string): string;
+//# sourceMappingURL=naming.d.ts.map

package/dist/commands/build/paths.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from '../../utils/config';
+import type { BuildOptions } from './types';
+export declare function resolveOperationPaths(specFile: string, sanitizedName: string, options: BuildOptions, config: Config): {
+    handlerPath: string;
+    testPath: string;
+};
+export declare function resolvePresentationPaths(specFile: string, sanitizedName: string, options: BuildOptions, config: Config): {
+    componentPath: string;
+    testPath: string;
+};
+export declare function resolveFormPaths(specFile: string, sanitizedName: string, options: BuildOptions, config: Config): {
+    formPath: string;
+    testPath: string;
+};
+export declare function resolveDataViewRendererPath(specFile: string, sanitizedName: string, options: BuildOptions, config: Config): string;
+export declare function resolveWorkflowRunnerPath(specFile: string, sanitizedName: string, options: BuildOptions, config: Config): string;
+export declare function resolveBaseOutputDir(options: BuildOptions, config: Config, subdir: string): string | null;
+export declare function computeRelativeImport(specFile: string, targetPath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/commands/build/spec-detect.d.ts

@@ -0,0 +1,9 @@
+export type SpecBuildType = 'operation' | 'presentation' | 'form' | 'event' | 'workflow' | 'data-view' | 'telemetry' | 'migration' | 'experiment' | 'app-config' | 'integration' | 'knowledge' | 'unknown';
+export declare function detectSpecType(specFile: string, specCode: string): SpecBuildType;
+export declare function extractMetaValue(specCode: string, field: string): string | null;
+export declare function extractOperationKind(specCode: string): 'command' | 'query' | null;
+export declare function deriveNameFromFile(specFile: string): string;
+export declare function extractWorkflowExportName(specCode: string): string | null;
+export declare function extractDataViewExportName(specCode: string): string | null;
+export declare function extractDataViewKind(specCode: string): string | null;
+//# sourceMappingURL=spec-detect.d.ts.map

package/dist/commands/build/types.d.ts

@@ -0,0 +1,11 @@
+export interface BuildOptions {
+    outputDir?: string;
+    provider?: string;
+    model?: string;
+    agentMode?: string;
+    noTests?: boolean;
+    noAgent?: boolean;
+}
+export type GenerationTarget = 'handler' | 'component' | 'form';
+export type TestTarget = 'handler' | 'component';
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/chat/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ContractSpec Chat Command
+ *
+ * Interactive AI chat for vibe coding within the CLI.
+ */
+import { Command } from 'commander';
+/**
+ * Create the chat command
+ */
+export declare const chatCommand: Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/ci/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CI command.
+ *
+ * Runs all ContractSpec validation checks for CI/CD pipelines.
+ * Supports multiple output formats: text, JSON, and SARIF.
+ */
+import { Command } from 'commander';
+export declare const ciCommand: Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/clean/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const cleanCommand: Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/create/ai-assist.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from '../../utils/config';
+import type { EventSpecData, OperationSpecData, OpKind, PresentationKind, PresentationSpecData } from '../../types';
+/**
+ * Use AI to generate operation spec from description
+ */
+export declare function aiGenerateOperation(description: string, kind: OpKind, config: Config): Promise<Partial<OperationSpecData>>;
+/**
+ * Use AI to generate event spec from description
+ */
+export declare function aiGenerateEvent(description: string, config: Config): Promise<Partial<EventSpecData>>;
+/**
+ * Use AI to generate presentation spec from description
+ */
+export declare function aiGeneratePresentation(description: string, kind: PresentationKind, config: Config): Promise<Partial<PresentationSpecData>>;
+//# sourceMappingURL=ai-assist.d.ts.map

package/dist/commands/create/create-app-config.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createAppConfigSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-app-config.d.ts.map

package/dist/commands/create/create-command.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createCommand(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-command.d.ts.map

package/dist/commands/create/create-data-view.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createDataViewSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-data-view.d.ts.map

package/dist/commands/create/create-event.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createEventSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-event.d.ts.map

package/dist/commands/create/create-experiment.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createExperimentSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-experiment.d.ts.map

package/dist/commands/create/create-integration.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createIntegrationSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-integration.d.ts.map

package/dist/commands/create/create-knowledge.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createKnowledgeSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-knowledge.d.ts.map

package/dist/commands/create/create-migration.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createMigrationSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-migration.d.ts.map

package/dist/commands/create/create-operation.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createOperationSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-operation.d.ts.map

package/dist/commands/create/create-presentation.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../utils/config';
+import type { CreateOptions } from './types';
+export declare function createPresentationSpec(options: CreateOptions, config: Config): Promise<void>;
+//# sourceMappingURL=create-presentation.d.ts.map