edsger 0.2.0 → 0.2.2

package/dist/api/features/feature-utils.d.ts

@@ -0,0 +1,13 @@
+import { FeatureInfo } from '../../types/features.js';
+/**
+ * Filter features by status
+ */
+export declare function filterFeaturesByStatus(features: FeatureInfo[], status: string): FeatureInfo[];
+/**
+ * Sort features by updated_at (most recent first)
+ */
+export declare function sortFeaturesByUpdatedAt(features: FeatureInfo[]): FeatureInfo[];
+/**
+ * Get features with ready_for_dev status for a product
+ */
+export declare function getReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;

package/dist/api/features/feature-utils.js

@@ -0,0 +1,46 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * 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/api/features/get-feature.d.ts

@@ -0,0 +1,5 @@
+import { FeatureInfo } from '../../types/features.js';
+/**
+ * Get feature details by ID
+ */
+export declare function getFeature(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<FeatureInfo>;

package/dist/api/features/get-feature.js

@@ -0,0 +1,19 @@
+import { logInfo } from '../../utils/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}`);
+    }
+    const feature = result.features[0];
+    if (!feature || typeof feature !== 'object') {
+        throw new Error(`Invalid feature data returned for: ${featureId}`);
+    }
+    return feature;
+}

package/dist/api/features/index.d.ts

@@ -0,0 +1,7 @@
+export * from './get-feature.js';
+export * from './update-feature.js';
+export * from './user-stories.js';
+export * from './test-cases.js';
+export * from './feature-utils.js';
+export * from './status-updater.js';
+export * from '../../types/features.js';

package/dist/api/features/index.js

@@ -0,0 +1,9 @@
+// Re-export all feature-related functions
+export * from './get-feature.js';
+export * from './update-feature.js';
+export * from './user-stories.js';
+export * from './test-cases.js';
+export * from './feature-utils.js';
+export * from './status-updater.js';
+// Re-export types
+export * from '../../types/features.js';

package/dist/api/features/status-updater.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Feature status updater for workflow pipeline
+ * Updates feature status at each phase of the development workflow
+ */
+import type { FeatureStatus } from '../../types/index.js';
+interface McpClientConfig {
+    readonly mcpServerUrl: string;
+    readonly mcpToken: string;
+}
+interface StatusUpdateOptions extends McpClientConfig {
+    readonly featureId: string;
+    readonly status: FeatureStatus;
+    readonly verbose?: boolean;
+}
+/**
+ * Update feature status via MCP endpoint
+ */
+export declare function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
+/**
+ * Map pipeline phase to feature status
+ */
+export declare const getStatusForPhase: (phase: string) => FeatureStatus;
+/**
+ * Update feature status based on pipeline phase
+ */
+export declare const updateFeatureStatusForPhase: (mcpConfig: McpClientConfig, featureId: string, phase: string, verbose?: boolean) => Promise<boolean>;
+export {};

package/dist/api/features/status-updater.js

@@ -0,0 +1,64 @@
+/**
+ * Feature status updater for workflow pipeline
+ * Updates feature status at each phase of the development workflow
+ */
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * Update feature status via MCP endpoint
+ */
+export async function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose = false, }) {
+    try {
+        if (verbose) {
+            logInfo(`Updating feature ${featureId} status to: ${status}`);
+        }
+        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
+            feature_id: featureId,
+            status,
+        });
+        if (verbose) {
+            logInfo(`✅ Feature status updated successfully to: ${status}`);
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            logError(`Failed to update feature status: ${errorMessage}`);
+        }
+        return false;
+    }
+}
+/**
+ * Map pipeline phase to feature status
+ */
+export const getStatusForPhase = (phase) => {
+    switch (phase) {
+        case 'feature-analysis':
+            return 'feature_analysis';
+        case 'technical-design':
+            return 'technical_design';
+        case 'code-implementation':
+            return 'code_implementation';
+        case 'functional-testing':
+            return 'testing_in_progress';
+        case 'testing-passed':
+            return 'testing_passed';
+        case 'testing-failed':
+            return 'testing_failed';
+        default:
+            return 'backlog';
+    }
+};
+/**
+ * Update feature status based on pipeline phase
+ */
+export const updateFeatureStatusForPhase = (mcpConfig, featureId, phase, verbose) => {
+    const status = getStatusForPhase(phase);
+    return updateFeatureStatus({
+        ...mcpConfig,
+        featureId,
+        status,
+        verbose,
+    });
+};

package/dist/api/features/test-cases.d.ts

@@ -0,0 +1,21 @@
+import { TestCase } from '../../types/features.js';
+/**
+ * Get test cases for a feature
+ */
+export declare function getTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TestCase[]>;
+/**
+ * Create a new test case for a feature
+ */
+export declare function createTestCase(mcpServerUrl: string, mcpToken: string, featureId: string, testCase: {
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Create multiple test cases for a feature
+ */
+export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: Array<{
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}>, verbose?: boolean): Promise<boolean>;

package/dist/api/features/test-cases.js

@@ -0,0 +1,63 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * 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;
+    }
+}

package/dist/api/features/update-feature.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Update feature with new data
+ */
+export declare function updateFeature(mcpServerUrl: string, mcpToken: string, featureId: string, updates: {
+    technical_design?: string;
+    status?: string;
+    pull_request_url?: string;
+    execution_mode?: string;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Update technical design for a feature
+ */
+export declare function updateTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;

package/dist/api/features/update-feature.js

@@ -0,0 +1,31 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * 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);
+}

package/dist/api/features/user-stories.d.ts

@@ -0,0 +1,21 @@
+import { UserStory } from '../../types/features.js';
+/**
+ * Get user stories for a feature
+ */
+export declare function getUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<UserStory[]>;
+/**
+ * Create a new user story for a feature
+ */
+export declare function createUserStory(mcpServerUrl: string, mcpToken: string, featureId: string, userStory: {
+    title: string;
+    description: string;
+    status?: string;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Create multiple user stories for a feature
+ */
+export declare function createUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, userStories: Array<{
+    title: string;
+    description: string;
+    status?: string;
+}>, verbose?: boolean): Promise<boolean>;

package/dist/api/features/user-stories.js

@@ -0,0 +1,63 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+/**
+ * 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;
+    }
+}

package/dist/api/features.d.ts

@@ -0,0 +1,100 @@
+export interface FeatureInfo {
+    id: string;
+    name: string;
+    description?: string;
+    technical_design?: string;
+    status: string;
+    product_id: string;
+    created_at?: string;
+    updated_at?: string;
+}
+/**
+ * Get feature details by ID
+ */
+export declare function getFeature(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<FeatureInfo>;
+/**
+ * Update feature with new data
+ */
+export declare function updateFeature(mcpServerUrl: string, mcpToken: string, featureId: string, updates: {
+    technical_design?: string;
+    status?: string;
+    pull_request_url?: string;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Update technical design for a feature
+ */
+export declare function updateTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Update feature status
+ */
+export declare function updateFeatureStatus(mcpServerUrl: string, mcpToken: string, featureId: string, status: string, verbose?: boolean): Promise<boolean>;
+export interface UserStory {
+    id: string;
+    title: string;
+    description: string;
+    status: string;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}
+/**
+ * Get user stories for a feature
+ */
+export declare function getUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<UserStory[]>;
+/**
+ * Create a new user story for a feature
+ */
+export declare function createUserStory(mcpServerUrl: string, mcpToken: string, featureId: string, userStory: {
+    title: string;
+    description: string;
+    status?: string;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Create multiple user stories for a feature
+ */
+export declare function createUserStories(mcpServerUrl: string, mcpToken: string, featureId: string, userStories: Array<{
+    title: string;
+    description: string;
+    status?: string;
+}>, verbose?: boolean): Promise<boolean>;
+export interface TestCase {
+    id: string;
+    name: string;
+    description: string;
+    is_critical: boolean;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}
+/**
+ * Get test cases for a feature
+ */
+export declare function getTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TestCase[]>;
+/**
+ * Create a new test case for a feature
+ */
+export declare function createTestCase(mcpServerUrl: string, mcpToken: string, featureId: string, testCase: {
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Create multiple test cases for a feature
+ */
+export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: Array<{
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}>, verbose?: boolean): Promise<boolean>;
+/**
+ * Filter features by status
+ */
+export declare function filterFeaturesByStatus(features: FeatureInfo[], status: string): FeatureInfo[];
+/**
+ * Sort features by updated_at (most recent first)
+ */
+export declare function sortFeaturesByUpdatedAt(features: FeatureInfo[]): FeatureInfo[];
+/**
+ * Get features with ready_for_dev status for a product
+ */
+export declare function getReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;