edsger 0.2.2 → 0.2.4

package/dist/api/features.js

@@ -1,219 +0,0 @@
-import { logInfo, logError } from '../logger.js';
-import { callMcpEndpoint } from './mcp-client.js';
-/**
- * Get feature details by ID
- */
-export async function getFeature(mcpServerUrl, mcpToken, featureId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching feature details for: ${featureId}`);
-    }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/get', { feature_id: featureId }));
-    if (!result.features || result.features.length === 0) {
-        throw new Error(`Feature not found: ${featureId}`);
-    }
-    return result.features[0];
-}
-/**
- * Update feature with new data
- */
-export async function updateFeature(mcpServerUrl, mcpToken, featureId, updates, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Updating feature: ${featureId}`);
-        }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
-            feature_id: featureId,
-            ...updates,
-        });
-        if (verbose) {
-            logInfo('✅ Feature updated successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to update feature: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Update technical design for a feature
- */
-export async function updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose) {
-    return updateFeature(mcpServerUrl, mcpToken, featureId, { technical_design: technicalDesign }, verbose);
-}
-/**
- * Update feature status
- */
-export async function updateFeatureStatus(mcpServerUrl, mcpToken, featureId, status, verbose) {
-    return updateFeature(mcpServerUrl, mcpToken, featureId, { status }, verbose);
-}
-/**
- * Get user stories for a feature
- */
-export async function getUserStories(mcpServerUrl, mcpToken, featureId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching user stories for feature: ${featureId}`);
-    }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/list', { feature_id: featureId }));
-    return (result.user_stories || []);
-}
-/**
- * Create a new user story for a feature
- */
-export async function createUserStory(mcpServerUrl, mcpToken, featureId, userStory, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating user story for feature: ${featureId}`);
-        }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/create', {
-            feature_id: featureId,
-            user_stories: [
-                {
-                    title: userStory.title,
-                    description: userStory.description,
-                    status: userStory.status || 'draft',
-                },
-            ],
-        });
-        if (verbose) {
-            logInfo('✅ User story created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create user story: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Create multiple user stories for a feature
- */
-export async function createUserStories(mcpServerUrl, mcpToken, featureId, userStories, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating ${userStories.length} user stories for feature: ${featureId}`);
-        }
-        for (const story of userStories) {
-            await createUserStory(mcpServerUrl, mcpToken, featureId, story, false);
-        }
-        if (verbose) {
-            logInfo('✅ All user stories created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create user stories: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Get test cases for a feature
- */
-export async function getTestCases(mcpServerUrl, mcpToken, featureId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching test cases for feature: ${featureId}`);
-    }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/list', { feature_id: featureId }));
-    return (result.test_cases || []);
-}
-/**
- * Create a new test case for a feature
- */
-export async function createTestCase(mcpServerUrl, mcpToken, featureId, testCase, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating test case for feature: ${featureId}`);
-        }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/create', {
-            feature_id: featureId,
-            test_cases: [
-                {
-                    name: testCase.name,
-                    description: testCase.description,
-                    is_critical: testCase.is_critical || false,
-                },
-            ],
-        });
-        if (verbose) {
-            logInfo('✅ Test case created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create test case: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Create multiple test cases for a feature
- */
-export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCases, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating ${testCases.length} test cases for feature: ${featureId}`);
-        }
-        for (const testCase of testCases) {
-            await createTestCase(mcpServerUrl, mcpToken, featureId, testCase, false);
-        }
-        if (verbose) {
-            logInfo('✅ All test cases created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create test cases: ${errorMessage}`);
-        return false;
-    }
-}
-// ============================================================================
-// FEATURE UTILITY FUNCTIONS
-// ============================================================================
-/**
- * Filter features by status
- */
-export function filterFeaturesByStatus(features, status) {
-    return features.filter(feature => feature.status === status);
-}
-/**
- * Sort features by updated_at (most recent first)
- */
-export function sortFeaturesByUpdatedAt(features) {
-    return [...features].sort((a, b) => {
-        const dateA = new Date(a.updated_at || 0).getTime();
-        const dateB = new Date(b.updated_at || 0).getTime();
-        return dateB - dateA;
-    });
-}
-/**
- * Get features with ready_for_dev status for a product
- */
-export async function getReadyForDevFeatures(mcpServerUrl, mcpToken, productId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching ready_for_dev features for product: ${productId}`);
-    }
-    try {
-        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/list', {
-            product_id: productId,
-            status: 'ready_for_dev',
-        });
-        const features = result.features || [];
-        const sortedFeatures = sortFeaturesByUpdatedAt(features);
-        if (verbose) {
-            logInfo(`✅ Found ${sortedFeatures.length} ready_for_dev features`);
-            sortedFeatures.forEach((feature, index) => {
-                logInfo(`   ${index + 1}. ${feature.name} (updated: ${feature.updated_at})`);
-            });
-        }
-        return sortedFeatures;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch ready_for_dev features: ${errorMessage}`);
-        throw error;
-    }
-}

package/dist/logger.d.ts

@@ -1,19 +0,0 @@
-import { ReviewResult } from './types.js';
-export declare const colors: {
-    reset: string;
-    bright: string;
-    red: string;
-    green: string;
-    yellow: string;
-    blue: string;
-    magenta: string;
-    cyan: string;
-    gray: string;
-};
-export declare const colorize: (text: string, color: keyof typeof colors) => string;
-export declare const logInfo: (message: string) => void;
-export declare const logSuccess: (message: string) => void;
-export declare const logWarning: (message: string) => void;
-export declare const logError: (message: string) => void;
-export declare const logProgress: (current: number, total: number, file: string) => void;
-export declare const logResults: (results: ReviewResult[], verbose?: boolean) => void;

package/dist/logger.js

@@ -1,52 +0,0 @@
-export const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    gray: '\x1b[90m'
-};
-export const colorize = (text, color) => {
-    return `${colors[color]}${text}${colors.reset}`;
-};
-export const logInfo = (message) => {
-    console.log(colorize(`ℹ ${message}`, 'blue'));
-};
-export const logSuccess = (message) => {
-    console.log(colorize(`✓ ${message}`, 'green'));
-};
-export const logWarning = (message) => {
-    console.log(colorize(`⚠ ${message}`, 'yellow'));
-};
-export const logError = (message) => {
-    console.error(colorize(`✗ ${message}`, 'red'));
-};
-export const logProgress = (current, total, file) => {
-    const percentage = Math.round((current / total) * 100);
-    const progress = `[${current}/${total}] ${percentage}%`;
-    console.log(colorize(`${progress} Reviewing ${file}`, 'gray'));
-};
-export const logResults = (results, verbose = false) => {
-    const okCount = results.filter(r => r.status === 'OK').length;
-    const warnCount = results.filter(r => r.status === 'WARN').length;
-    const blockCount = results.filter(r => r.status === 'BLOCK').length;
-    console.log('\n' + colorize('='.repeat(60), 'gray'));
-    console.log(colorize('Review Results', 'bright'));
-    console.log(colorize('='.repeat(60), 'gray'));
-    results.forEach(result => {
-        const icon = result.status === 'OK' ? '✓' : result.status === 'WARN' ? '⚠' : '✗';
-        const color = result.status === 'OK' ? 'green' : result.status === 'WARN' ? 'yellow' : 'red';
-        console.log(colorize(`${icon} ${result.file}: ${result.message}`, color));
-        if (verbose && result.details && result.status !== 'OK') {
-            console.log(colorize(`   Details: ${result.details}`, 'gray'));
-        }
-    });
-    console.log('\n' + colorize('Summary:', 'bright'));
-    console.log(colorize(`  ✓ Passed: ${okCount}`, 'green'));
-    console.log(colorize(`  ⚠ Warnings: ${warnCount}`, 'yellow'));
-    console.log(colorize(`  ✗ Blocked: ${blockCount}`, 'red'));
-    console.log(colorize(`  Total: ${results.length} files reviewed`, 'gray'));
-};

package/dist/types.d.ts

@@ -1,99 +0,0 @@
-export interface EdsgerConfig {
-    patterns: string[];
-    exclude: string[];
-    severity: 'error' | 'warning';
-    maxFiles: number;
-    claude: {
-        model?: string;
-        timeout?: number;
-    };
-}
-export interface GitFile {
-    path: string;
-    content: string;
-    status: 'modified' | 'added' | 'deleted' | 'renamed';
-}
-export interface ReviewResult {
-    file: string;
-    status: 'OK' | 'WARN' | 'BLOCK';
-    message: string;
-    details?: string;
-}
-export interface CliOptions {
-    review?: boolean;
-    staged?: boolean;
-    files?: string[];
-    config?: string;
-    verbose?: boolean;
-    featureAnalysis?: string;
-    technicalDesign?: string;
-    implement?: string;
-    test?: string;
-    workflow?: boolean;
-}
-export type ReviewSeverity = 'error' | 'warning';
-export type ExitCode = 0 | 1;
-export interface FeatureAnalysisResult {
-    featureId: string;
-    productInfo: unknown;
-    featureInfo: unknown;
-    existingUserStories: UserStory[];
-    existingTestCases: TestCase[];
-    createdUserStories: UserStory[];
-    createdTestCases: TestCase[];
-    summary: string;
-    status: 'pending' | 'success' | 'error';
-}
-export interface FeatureData {
-    feature: {
-        id: string;
-        name: string;
-        description: string;
-        status: string;
-        product_id: string;
-        created_at: string;
-        updated_at: string;
-    };
-    product: {
-        id: string;
-        name: string;
-        description: string;
-        status: string;
-        features: unknown[];
-        metadata: {
-            created_at: string;
-            updated_at: string;
-        };
-    };
-}
-export interface UserStory {
-    id: string;
-    title: string;
-    description: string;
-    status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled';
-    created_at: string;
-    updated_at: string;
-}
-export interface TestCase {
-    id: string;
-    name: string;
-    description: string;
-    is_critical: boolean;
-    created_at: string;
-    updated_at: string;
-}
-export interface DisplayUserStory {
-    title: string;
-}
-export interface DisplayTestCase {
-    name: string;
-    is_critical?: boolean;
-}
-export interface FeatureAnalysisDisplayResult {
-    featureId: string;
-    status: string;
-    summary?: string;
-    createdUserStories?: DisplayUserStory[];
-    createdTestCases?: DisplayTestCase[];
-}
-export type FeatureStatus = 'backlog' | 'ready_for_dev' | 'feature_analysis' | 'technical_design' | 'code_implementation' | 'code_review' | 'ready_for_review' | 'shipped' | 'testing_in_progress' | 'testing_passed' | 'testing_failed';

package/dist/types.js

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

package/dist/workflow-runner/config/stage-configs.d.ts

@@ -1,5 +0,0 @@
-/**
- * Stage configurations for the pipeline runner
- */
-import { StageConfig } from '../../types/pipeline.js';
-export declare const stageConfigs: readonly StageConfig[];

package/dist/workflow-runner/config/stage-configs.js

@@ -1,34 +0,0 @@
-/**
- * Stage configurations for the pipeline runner
- */
-import { analyzeFeatureWithMCP, checkFeatureAnalysisRequirements, } from '../../phases/feature-analysis/analyzer.js';
-import { generateTechnicalDesign, checkTechnicalDesignRequirements, } from '../../phases/technical-design/analyzer.js';
-import { implementFeatureCode, checkCodeImplementationRequirements, } from '../../phases/code-implementation/analyzer.js';
-import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../../phases/functional-testing/analyzer.js';
-// Pipeline stage configurations
-export const stageConfigs = [
-    {
-        name: 'feature-analysis',
-        checkRequirements: checkFeatureAnalysisRequirements,
-        execute: analyzeFeatureWithMCP,
-        requirementsError: 'Feature analysis requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'technical-design',
-        checkRequirements: checkTechnicalDesignRequirements,
-        execute: generateTechnicalDesign,
-        requirementsError: 'Technical design requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'code-implementation',
-        checkRequirements: checkCodeImplementationRequirements,
-        execute: implementFeatureCode,
-        requirementsError: 'Code implementation requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-    {
-        name: 'functional-testing',
-        checkRequirements: checkFunctionalTestingRequirements,
-        execute: runFunctionalTesting,
-        requirementsError: 'Functional testing requirements not met. Install with: npm install @anthropic-ai/claude-code zod',
-    },
-];

package/dist/workflow-runner/core/feature-filter.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for feature filtering with timestamp-based reprocessing
- */
-export {};

package/dist/workflow-runner/core/feature-filter.test.js

@@ -1,127 +0,0 @@
-/**
- * Unit tests for feature filtering with timestamp-based reprocessing
- */
-import { shouldProcessFeature } from './feature-filter.js';
-describe('shouldProcessFeature with timestamp checking', () => {
-    const maxRetries = 3;
-    it('should process feature that has never been processed', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T10:00:00Z',
-        };
-        const states = new Map();
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(true);
-    });
-    it('should reprocess completed feature if updated after last attempt', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T12:00:00Z', // Updated at noon
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 1,
-            lastAttempt: new Date('2024-01-01T10:00:00Z'), // Processed at 10 AM
-            status: 'completed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(true); // Should reprocess because updated after last attempt
-    });
-    it('should not reprocess completed feature if not updated after last attempt', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T10:00:00Z', // Updated at 10 AM
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 1,
-            lastAttempt: new Date('2024-01-01T12:00:00Z'), // Processed at noon
-            status: 'completed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(false); // Should not reprocess because not updated after last attempt
-    });
-    it('should reprocess failed feature if updated after last attempt', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T12:00:00Z', // Updated at noon
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 2,
-            lastAttempt: new Date('2024-01-01T10:00:00Z'), // Failed at 10 AM
-            status: 'failed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(true); // Should reprocess because updated after last attempt
-    });
-    it('should reprocess failed feature within retry limit even without update', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T09:00:00Z', // Not updated
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 2, // Less than maxRetries (3)
-            lastAttempt: new Date('2024-01-01T10:00:00Z'),
-            status: 'failed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(true); // Should retry because within retry limit
-    });
-    it('should not reprocess failed feature beyond retry limit without update', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            updated_at: '2024-01-01T09:00:00Z', // Not updated
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 3, // Equal to maxRetries
-            lastAttempt: new Date('2024-01-01T10:00:00Z'),
-            status: 'failed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(false); // Should not retry because exceeded retry limit
-    });
-    it('should handle feature without updated_at timestamp', () => {
-        const feature = {
-            id: 'feature-1',
-            name: 'Test Feature',
-            status: 'ready_for_dev',
-            product_id: 'product-1',
-            // No updated_at field
-        };
-        const states = new Map();
-        states.set('feature-1', {
-            featureId: 'feature-1',
-            retryCount: 1,
-            lastAttempt: new Date('2024-01-01T10:00:00Z'),
-            status: 'completed',
-        });
-        const result = shouldProcessFeature(maxRetries)(feature, states);
-        expect(result).toBe(false); // Should not reprocess without timestamp info
-    });
-});

package/dist/workflow-runner/executors/stage-executor.d.ts

@@ -1,8 +0,0 @@
-/**
- * Stage execution logic for pipeline runner
- */
-import { EdsgerConfig } from '../../types/index.js';
-import { PipelineStageOptions, PipelineResult, StageConfig } from '../../types/pipeline.js';
-export declare const createStageRunner: (stageConfig: StageConfig) => (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingStage: (options: PipelineStageOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

package/dist/workflow-runner/executors/stage-executor.js

@@ -1,49 +0,0 @@
-/**
- * Stage execution logic for pipeline runner
- */
-import { updateFeatureStatusForStage } from '../../api/features/index.js';
-import { stageConfigs } from '../config/stage-configs.js';
-// Higher-order function for stage execution
-export const createStageRunner = (stageConfig) => async (options, config) => {
-    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
-    const { name, checkRequirements, execute, requirementsError } = stageConfig;
-    try {
-        // Check requirements
-        const hasRequirements = await checkRequirements();
-        if (!hasRequirements) {
-            return {
-                featureId,
-                stage: name,
-                status: 'error',
-                message: requirementsError,
-            };
-        }
-        // Update feature status to reflect current stage
-        await updateFeatureStatusForStage({ mcpServerUrl, mcpToken }, featureId, name, verbose);
-        if (verbose) {
-            console.log(`🎯 Starting ${name} for: ${featureId}`);
-        }
-        const result = await execute(options, config);
-        return {
-            featureId,
-            stage: name,
-            status: result.status === 'success' ? 'success' : 'error',
-            message: result.status === 'success'
-                ? `${name.replace('-', ' ')} completed successfully`
-                : `${name.replace('-', ' ')} failed`,
-            data: result,
-        };
-    }
-    catch (error) {
-        return {
-            featureId,
-            stage: name,
-            status: 'error',
-            message: `${name.replace('-', ' ')} failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-};
-// Create stage runners using the configuration
-const [runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage,] = stageConfigs.map(createStageRunner);
-// Export individual stage runners for granular control
-export { runFeatureAnalysisStage, runTechnicalDesignStage, runCodeImplementationStage, runFunctionalTestingStage, };

package/dist/workflow-runner/feature-fetcher.d.ts

@@ -1,41 +0,0 @@
-/**
- * Feature fetcher module for workflow processing
- * Fetches features with ready_for_dev status and handles product queries via MCP
- * Uses functional programming principles
- */
-export interface McpClientConfig {
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly verbose?: boolean;
-}
-export declare const createMcpClient: (config: McpClientConfig) => {
-    call: <T>(method: string, params: unknown) => Promise<T>;
-};
-export interface FeatureInfo {
-    readonly id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly status: string;
-    readonly product_id: string;
-    readonly created_at: string;
-    readonly updated_at: string;
-}
-export interface FetchFeaturesOptions {
-    readonly mcpServerUrl: string;
-    readonly mcpToken: string;
-    readonly productId: string;
-    readonly verbose?: boolean;
-}
-declare const filterFeaturesByStatus: (status: string) => (features: FeatureInfo[]) => FeatureInfo[];
-declare const sortFeaturesByUpdatedAt: (features: FeatureInfo[]) => FeatureInfo[];
-/**
- * Fetch all features with ready_for_dev status for a product, sorted by updated_at
- * Pure functional approach with composition
- */
-export declare const fetchReadyForDevFeatures: (options: FetchFeaturesOptions) => () => Promise<FeatureInfo[]>;
-/**
- * Get feature details by ID
- * Functional approach with error handling
- */
-export declare const getFeatureDetails: (featureId: string, options: Omit<FetchFeaturesOptions, "productId">) => () => Promise<FeatureInfo | null>;
-export { filterFeaturesByStatus, sortFeaturesByUpdatedAt };