edsger 0.33.5 → 0.34.0

package/dist/api/__tests__/app-store.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unit tests for app-store API helpers.
+ *
+ * Tests the parsing/extraction logic that getAppStorePrimaryLocale uses
+ * to parse MCP response data.
+ */
+export {};

package/dist/api/__tests__/app-store.test.js

@@ -0,0 +1,60 @@
+/**
+ * Unit tests for app-store API helpers.
+ *
+ * Tests the parsing/extraction logic that getAppStorePrimaryLocale uses
+ * to parse MCP response data.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+/**
+ * Extracts locale from an MCP response — mirrors the parsing logic
+ * inside getAppStorePrimaryLocale without requiring network mocks.
+ */
+function parseLocaleFromMcpResponse(result) {
+    const text = result?.content?.[0]?.text || '{}';
+    const parsed = JSON.parse(text);
+    return parsed.locale || null;
+}
+void describe('parseLocaleFromMcpResponse', () => {
+    void it('should return locale string when present', () => {
+        const result = { content: [{ text: '{"locale":"en-US"}' }] };
+        assert.strictEqual(parseLocaleFromMcpResponse(result), 'en-US');
+    });
+    void it('should return locale for non-English locales', () => {
+        assert.strictEqual(parseLocaleFromMcpResponse({ content: [{ text: '{"locale":"ja"}' }] }), 'ja');
+        assert.strictEqual(parseLocaleFromMcpResponse({
+            content: [{ text: '{"locale":"zh-Hans"}' }],
+        }), 'zh-Hans');
+        assert.strictEqual(parseLocaleFromMcpResponse({ content: [{ text: '{"locale":"fr-FR"}' }] }), 'fr-FR');
+    });
+    void it('should return null when locale is null', () => {
+        const result = { content: [{ text: '{"locale":null}' }] };
+        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
+    });
+    void it('should return null when locale is empty string', () => {
+        const result = { content: [{ text: '{"locale":""}' }] };
+        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
+    });
+    void it('should return null when content array is empty', () => {
+        const result = { content: [] };
+        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
+    });
+    void it('should return null when content field is missing', () => {
+        assert.strictEqual(parseLocaleFromMcpResponse({}), null);
+    });
+    void it('should return null when result is null', () => {
+        assert.strictEqual(parseLocaleFromMcpResponse(null), null);
+    });
+    void it('should return null when result is undefined', () => {
+        assert.strictEqual(parseLocaleFromMcpResponse(undefined), null);
+    });
+    void it('should throw when text is not valid JSON', () => {
+        assert.throws(() => {
+            parseLocaleFromMcpResponse({ content: [{ text: 'not json' }] });
+        });
+    });
+    void it('should return null when text field is missing', () => {
+        const result = { content: [{}] };
+        assert.strictEqual(parseLocaleFromMcpResponse(result), null);
+    });
+});

package/dist/api/app-store.d.ts

@@ -5,7 +5,7 @@ export interface AppStoreConfig {
     credentials: Record<string, unknown>;
     app_identifier: string | null;
     listings: Record<string, AppStoreListing>;
-    screenshots: AppStoreScreenshot[];
+    screenshots: Record<string, AppStoreScreenshot[]>;
     current_version: string | null;
     submission_status: string;
     submitted_at: string | null;
@@ -39,7 +39,6 @@ export interface AppStoreScreenshot {
     caption: string;
     background_gradient: string;
     device_frame: string;
-    locale: string;
 }
 /**
  * Get app store configs for a product via MCP
@@ -65,7 +64,7 @@ export declare function saveAppStoreListings(configId: string, listings: Record<
 /**
  * Save screenshots to an app store config via MCP
  */
-export declare function saveAppStoreScreenshots(configId: string, screenshots: AppStoreScreenshot[], verbose?: boolean): Promise<AppStoreConfig | null>;
+export declare function saveAppStoreScreenshots(configId: string, screenshots: Record<string, AppStoreScreenshot[]>, verbose?: boolean): Promise<AppStoreConfig | null>;
 /**
  * Update submission status via MCP
  */
@@ -74,3 +73,8 @@ export declare function updateAppStoreStatus(configId: string, updates: {
     current_version?: string;
     rejection_reason?: string;
 }, verbose?: boolean): Promise<AppStoreConfig | null>;
+/**
+ * Fetch the primary locale from Apple App Store Connect API via MCP.
+ * Returns the locale string (e.g. "en-US") or null if unavailable.
+ */
+export declare function getAppStorePrimaryLocale(productId: string, verbose?: boolean): Promise<string | null>;

package/dist/api/app-store.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../utils/logger.js';
+import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
  * Get app store configs for a product via MCP
@@ -101,7 +101,8 @@ export async function saveAppStoreListings(configId, listings, verbose) {
  */
 export async function saveAppStoreScreenshots(configId, screenshots, verbose) {
     if (verbose) {
-        logInfo(`Saving ${screenshots.length} screenshots for config: ${configId}`);
+        const total = Object.values(screenshots).flat().length;
+        logInfo(`Saving ${total} screenshots (${Object.keys(screenshots).length} locale(s)) for config: ${configId}`);
     }
     try {
         const result = (await callMcpEndpoint('app_store/configs/save_screenshots', {
@@ -146,3 +147,35 @@ export async function updateAppStoreStatus(configId, updates, verbose) {
         return null;
     }
 }
+/**
+ * Fetch the primary locale from Apple App Store Connect API via MCP.
+ * Returns the locale string (e.g. "en-US") or null if unavailable.
+ */
+export async function getAppStorePrimaryLocale(productId, verbose) {
+    if (verbose) {
+        logInfo(`Fetching primary locale from Apple App Store for product: ${productId}`);
+    }
+    try {
+        const result = (await callMcpEndpoint('app_store/primary_locale', {
+            product_id: productId,
+        }));
+        const text = result.content?.[0]?.text || '{}';
+        const parsed = JSON.parse(text);
+        const locale = parsed.locale || null;
+        if (verbose) {
+            if (locale) {
+                logInfo(`Primary locale from Apple: ${locale}`);
+            }
+            else {
+                logInfo('No primary locale returned from Apple API');
+            }
+        }
+        return locale;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch primary locale: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return null;
+    }
+}

package/dist/api/chat.d.ts

@@ -2,7 +2,7 @@
  * MCP client wrappers for chat operations.
  * Used by the chat-worker subprocess to interact with chat channels and messages.
  */
-import type { ChatChannel, ChatChannelType, ChatMode, ChatMessage, ChatMessageType } from '../types/index.js';
+import type { ChatChannel, ChatChannelType, ChatMessage, ChatMessageType, ChatMode } from '../types/index.js';
 export declare function getOrCreateChannel(channelType: ChatChannelType, channelRefId: string | null, chatMode?: ChatMode, name?: string, verbose?: boolean): Promise<{
     channel: ChatChannel;
     created: boolean;
@@ -20,7 +20,7 @@ export declare function sendAiMessage(channelId: string, content: string, metada
     parentMessageId?: string;
 }, verbose?: boolean): Promise<ChatMessage>;
 export declare function sendSystemMessage(channelId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
-export declare function getPendingMessages(channelId: string, verbose?: boolean): Promise<ChatMessage[]>;
+export declare function getPendingMessages(channelId: string, _verbose?: boolean): Promise<ChatMessage[]>;
 /**
  * Atomically claim pending messages for a channel.
  * Uses FOR UPDATE SKIP LOCKED at the database level so multiple CLI workers
@@ -31,8 +31,8 @@ export declare function claimPendingMessages(channelId: string, workerId: string
     staleTimeoutSeconds?: number;
 }, verbose?: boolean): Promise<ChatMessage[]>;
 export declare function markMessageProcessed(messageId: string, verbose?: boolean): Promise<void>;
-export declare function markChannelRead(channelId: string, lastReadMessageId?: string, verbose?: boolean): Promise<void>;
-export declare function getUnreadCount(channelId: string, verbose?: boolean): Promise<number>;
+export declare function markChannelRead(channelId: string, lastReadMessageId?: string, _verbose?: boolean): Promise<void>;
+export declare function getUnreadCount(channelId: string, _verbose?: boolean): Promise<number>;
 /**
  * Get or create the group chat channel for a product.
  * Every product has one group channel.

package/dist/api/chat.js

@@ -2,8 +2,8 @@
  * MCP client wrappers for chat operations.
  * Used by the chat-worker subprocess to interact with chat channels and messages.
  */
+import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
-import { logInfo, logError } from '../utils/logger.js';
 // ============================================================
 // Channels
 // ============================================================
@@ -88,7 +88,7 @@ export async function sendSystemMessage(channelId, content, metadata = {}, verbo
     }));
     return result.message;
 }
-export async function getPendingMessages(channelId, verbose) {
+export async function getPendingMessages(channelId, _verbose) {
     const result = (await callMcpEndpoint('chat/messages/pending', {
         channel_id: channelId,
     }));
@@ -122,13 +122,13 @@ export async function markMessageProcessed(messageId, verbose) {
 // ============================================================
 // Read Status
 // ============================================================
-export async function markChannelRead(channelId, lastReadMessageId, verbose) {
+export async function markChannelRead(channelId, lastReadMessageId, _verbose) {
     await callMcpEndpoint('chat/read_status/mark_read', {
         channel_id: channelId,
         last_read_message_id: lastReadMessageId,
     });
 }
-export async function getUnreadCount(channelId, verbose) {
+export async function getUnreadCount(channelId, _verbose) {
     const result = (await callMcpEndpoint('chat/read_status/unread_count', {
         channel_id: channelId,
     }));

package/dist/api/cross-product.d.ts

@@ -5,7 +5,7 @@
  * processes features from all products the user has access to,
  * not just a single product.
  */
-import { FeatureInfo } from '../types/features.js';
+import { type FeatureInfo } from '../types/features.js';
 export interface ProductSummary {
     id: string;
     name: string;

package/dist/api/cross-product.js

@@ -5,8 +5,8 @@
  * processes features from all products the user has access to,
  * not just a single product.
  */
+import { logError, logInfo } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
-import { logInfo, logError } from '../utils/logger.js';
 /**
  * List all products the authenticated user has access to
  */

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

@@ -1,12 +1,12 @@
 /**
  * Unit tests for feature utility functions
  */
-import { describe, it } from 'node:test';
 import assert from 'node:assert';
+import { describe, it } from 'node:test';
 import { filterFeaturesByStatus, sortFeaturesByUpdatedAt, } from '../feature-utils.js';
-describe('Feature Utils', () => {
-    describe('sortFeaturesByUpdatedAt', () => {
-        it('should sort features by updated_at in ascending order (oldest first)', () => {
+void describe('Feature Utils', () => {
+    void describe('sortFeaturesByUpdatedAt', () => {
+        void it('should sort features by updated_at in ascending order (oldest first)', () => {
             const features = [
                 {
                     id: '1',
@@ -36,7 +36,7 @@ describe('Feature Utils', () => {
             assert.strictEqual(sorted[1].id, '1', 'Second should be Feature 1');
             assert.strictEqual(sorted[2].id, '3', 'Third should be Feature 3 (newest)');
         });
-        it('should handle features with missing updated_at dates', () => {
+        void it('should handle features with missing updated_at dates', () => {
             const features = [
                 {
                     id: '1',
@@ -67,12 +67,12 @@ describe('Feature Utils', () => {
             assert.strictEqual(sorted[1].id, '3', 'Feature 3 should be second (older date)');
             assert.strictEqual(sorted[2].id, '1', 'Feature 1 should be third (newer date)');
         });
-        it('should handle empty array', () => {
+        void it('should handle empty array', () => {
             const features = [];
             const sorted = sortFeaturesByUpdatedAt(features);
             assert.strictEqual(sorted.length, 0, 'Empty array should remain empty');
         });
-        it('should handle single feature', () => {
+        void it('should handle single feature', () => {
             const features = [
                 {
                     id: '1',
@@ -86,7 +86,7 @@ describe('Feature Utils', () => {
             assert.strictEqual(sorted.length, 1, 'Should return single feature');
             assert.strictEqual(sorted[0].id, '1', 'Should be the same feature');
         });
-        it('should create a new array and not mutate the original', () => {
+        void it('should create a new array and not mutate the original', () => {
             const features = [
                 {
                     id: '1',
@@ -111,7 +111,7 @@ describe('Feature Utils', () => {
             // Sorted array should be different
             assert.notDeepStrictEqual(sorted.map((f) => f.id), originalOrder, 'Sorted array should have different order');
         });
-        it('should handle features with same updated_at timestamps consistently', () => {
+        void it('should handle features with same updated_at timestamps consistently', () => {
             const sameTimestamp = '2024-01-15T10:00:00Z';
             const features = [
                 {
@@ -141,7 +141,7 @@ describe('Feature Utils', () => {
             // Order should be stable (same as original for equal timestamps)
             // Note: JavaScript sort is stable in modern engines
         });
-        it('should handle various date formats correctly', () => {
+        void it('should handle various date formats correctly', () => {
             const features = [
                 {
                     id: '1',
@@ -172,8 +172,8 @@ describe('Feature Utils', () => {
             assert.strictEqual(sorted[2].id, '3', 'Feature 3 should be third (newest)');
         });
     });
-    describe('filterFeaturesByStatus', () => {
-        it('should filter features by exact status match', () => {
+    void describe('filterFeaturesByStatus', () => {
+        void it('should filter features by exact status match', () => {
             const features = [
                 {
                     id: '1',
@@ -199,7 +199,7 @@ describe('Feature Utils', () => {
             assert.strictEqual(filtered[0].id, '1', 'Should include Feature 1');
             assert.strictEqual(filtered[1].id, '3', 'Should include Feature 3');
         });
-        it('should return empty array when no features match status', () => {
+        void it('should return empty array when no features match status', () => {
             const features = [
                 {
                     id: '1',
@@ -217,14 +217,14 @@ describe('Feature Utils', () => {
             const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
             assert.strictEqual(filtered.length, 0, 'Should return empty array');
         });
-        it('should handle empty input array', () => {
+        void it('should handle empty input array', () => {
             const features = [];
             const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
             assert.strictEqual(filtered.length, 0, 'Should return empty array');
         });
     });
-    describe('Integration Tests - Workflow Processing Order', () => {
-        it('should process features in oldest-first order for workflow execution', () => {
+    void describe('Integration Tests - Workflow Processing Order', () => {
+        void it('should process features in oldest-first order for workflow execution', () => {
             // This test simulates the expected behavior for workflow processing
             const simulatedWorkflowFeatures = [
                 {
@@ -260,7 +260,7 @@ describe('Feature Utils', () => {
                 assert.ok(timestamps[i] >= timestamps[i - 1], `Feature ${i} should have timestamp >= feature ${i - 1}`);
             }
         });
-        it('should maintain consistent ordering across multiple calls', () => {
+        void it('should maintain consistent ordering across multiple calls', () => {
             const features = [
                 {
                     id: '1',
@@ -292,7 +292,7 @@ describe('Feature Utils', () => {
             assert.deepStrictEqual(sorted1.map((f) => f.id), sorted2.map((f) => f.id), 'First and second sort should produce same order');
             assert.deepStrictEqual(sorted2.map((f) => f.id), sorted3.map((f) => f.id), 'Second and third sort should produce same order');
         });
-        it('should verify oldest-first ordering is critical for fair workflow processing', () => {
+        void it('should verify oldest-first ordering is critical for fair workflow processing', () => {
             // Test that demonstrates why oldest-first ordering is important
             const featuresWithVariousAges = [
                 {
@@ -324,12 +324,12 @@ describe('Feature Utils', () => {
             assert.strictEqual(orderedFeatures[2].id, 'new-enhancement');
             // Verify the business logic: older items get processed before newer ones
             // This ensures fairness and prevents newer features from always jumping ahead
-            const ages = orderedFeatures.map((f) => new Date(f.updated_at).getTime());
+            const ages = orderedFeatures.map((f) => new Date(f.updated_at ?? '').getTime());
             assert.ok(ages[0] <= ages[1] && ages[1] <= ages[2], 'Features should be processed in age order (oldest first)');
         });
     });
-    describe('getReadyForAIFeatures integration behavior', () => {
-        it('should use sortFeaturesByUpdatedAt to ensure oldest-first processing', () => {
+    void describe('getReadyForAIFeatures integration behavior', () => {
+        void it('should use sortFeaturesByUpdatedAt to ensure oldest-first processing', () => {
             // This test verifies the integration between getReadyForAIFeatures and sortFeaturesByUpdatedAt
             // We can test this indirectly by testing the sorting function that getReadyForAIFeatures uses
             const mockApiResponse = [

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

@@ -1,34 +1,34 @@
 /**
  * Unit tests for status progression logic
  */
-import { describe, it } from 'node:test';
 import assert from 'node:assert';
+import { describe, it } from 'node:test';
 import { STATUS_PROGRESSION_ORDER } from '../../../config/feature-status.js';
 import { isForwardProgression } from '../status-updater.js';
-describe('Status Progression Logic', () => {
-    describe('isForwardProgression', () => {
-        it('should allow forward progression', () => {
+void describe('Status Progression Logic', () => {
+    void describe('isForwardProgression', () => {
+        void it('should allow forward progression', () => {
             assert.strictEqual(isForwardProgression('backlog', 'ready_for_ai'), true, 'Should allow progression from backlog to ready_for_ai');
             assert.strictEqual(isForwardProgression('feature_analysis', 'technical_design'), true, 'Should allow progression from feature_analysis to technical_design');
             assert.strictEqual(isForwardProgression('code_implementation', 'shipped'), true, 'Should allow progression from code_implementation to shipped');
         });
-        it('should allow staying at same status', () => {
+        void it('should allow staying at same status', () => {
             assert.strictEqual(isForwardProgression('backlog', 'backlog'), true, 'Should allow staying at backlog status');
             assert.strictEqual(isForwardProgression('feature_analysis', 'feature_analysis'), true, 'Should allow staying at feature_analysis status');
             assert.strictEqual(isForwardProgression('shipped', 'shipped'), true, 'Should allow staying at shipped status');
         });
-        it('should prevent backward progression', () => {
+        void it('should prevent backward progression', () => {
             assert.strictEqual(isForwardProgression('ready_for_ai', 'backlog'), false, 'Should prevent regression from ready_for_ai to backlog');
             assert.strictEqual(isForwardProgression('technical_design', 'feature_analysis'), false, 'Should prevent regression from technical_design to feature_analysis');
             assert.strictEqual(isForwardProgression('shipped', 'code_implementation'), false, 'Should prevent regression from shipped to code_implementation');
         });
-        it('should handle edge cases correctly', () => {
+        void it('should handle edge cases correctly', () => {
             // First status to last status
             assert.strictEqual(isForwardProgression('backlog', 'shipped'), true, 'Should allow progression from first to last status');
             // Last status to first status
             assert.strictEqual(isForwardProgression('shipped', 'backlog'), false, 'Should prevent regression from last to first status');
         });
-        it('should handle testing workflow correctly', () => {
+        void it('should handle testing workflow correctly', () => {
             // Allow progression through testing states
             assert.strictEqual(isForwardProgression('functional_testing', 'testing_in_progress'), true, 'Should allow progression to testing_in_progress');
             assert.strictEqual(isForwardProgression('testing_in_progress', 'testing_passed'), true, 'Should allow progression to testing_passed');
@@ -38,8 +38,8 @@ describe('Status Progression Logic', () => {
             assert.strictEqual(isForwardProgression('testing_passed', 'testing_in_progress'), false, 'Should prevent going back from testing_passed to testing_in_progress');
         });
     });
-    describe('STATUS_PROGRESSION_ORDER', () => {
-        it('should contain all expected statuses', () => {
+    void describe('STATUS_PROGRESSION_ORDER', () => {
+        void it('should contain all expected statuses', () => {
             const expectedStatuses = [
                 'backlog',
                 'ready_for_ai',
@@ -67,7 +67,7 @@ describe('Status Progression Logic', () => {
                 assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Should include status: ${status}`);
             }
         });
-        it('should have correct ordering for key workflow phases', () => {
+        void it('should have correct ordering for key workflow phases', () => {
             const backlogIndex = STATUS_PROGRESSION_ORDER.indexOf('backlog');
             const readyForDevIndex = STATUS_PROGRESSION_ORDER.indexOf('ready_for_ai');
             const featureAnalysisIndex = STATUS_PROGRESSION_ORDER.indexOf('feature_analysis');
@@ -80,7 +80,7 @@ describe('Status Progression Logic', () => {
             assert.ok(technicalDesignIndex < codeImplementationIndex, 'technical_design should come before code_implementation');
             assert.ok(codeImplementationIndex < shippedIndex, 'code_implementation should come before shipped');
         });
-        it('should not have duplicate statuses', () => {
+        void it('should not have duplicate statuses', () => {
             const uniqueStatuses = new Set(STATUS_PROGRESSION_ORDER);
             assert.strictEqual(uniqueStatuses.size, STATUS_PROGRESSION_ORDER.length, 'Should not contain duplicate statuses');
         });

package/dist/api/features/approval-checker.js

@@ -2,7 +2,7 @@
  * Approval workflow integration for feature phases
  * Checks if current feature status has been approved before executing next phase
  */
-import { logInfo, logError, logWarning } from '../../utils/logger.js';
+import { logError, logInfo, logWarning } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 import { getFeature } from './get-feature.js';
 /**

package/dist/api/features/batch-operations.d.ts

@@ -1,4 +1,4 @@
-import { UserStoryStatus, TestCaseStatus } from '../../types/index.js';
+import { type TestCaseStatus, type UserStoryStatus } from '../../types/index.js';
 /**
  * Batch update user story statuses
  */

package/dist/api/features/batch-operations.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../../utils/logger.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Batch update user story statuses

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

@@ -1,4 +1,4 @@
-import { FeatureInfo } from '../../types/features.js';
+import { type FeatureInfo } from '../../types/features.js';
 /**
  * Claim the next available ready_for_ai feature for processing.
  * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent

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

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../../utils/logger.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Claim the next available ready_for_ai feature for processing.

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

@@ -1,4 +1,4 @@
-import { FeatureInfo } from '../../types/features.js';
+import { type FeatureInfo } from '../../types/features.js';
 /**
  * Get feature details by ID
  */

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

@@ -1,8 +1,8 @@
+export * from './batch-operations.js';
+export * from './feature-utils.js';
 export * from './get-feature.js';
+export * from './status-updater.js';
+export * from './test-cases.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 './batch-operations.js';
 export * from '../../types/features.js';

package/dist/api/features/index.js

@@ -1,10 +1,10 @@
 // Re-export all feature-related functions
+export * from './batch-operations.js';
+export * from './feature-utils.js';
 export * from './get-feature.js';
+export * from './status-updater.js';
+export * from './test-cases.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 './batch-operations.js';
 // Re-export types
 export * from '../../types/features.js';

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

@@ -2,10 +2,10 @@
  * Feature status updater for workflow pipeline
  * Updates feature status at each phase of the development workflow
  */
-import { logInfo, logError } from '../../utils/logger.js';
+import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/feature-status.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 import { getFeature } from './get-feature.js';
-import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../../config/feature-status.js';
 /**
  * Check if moving from currentStatus to newStatus is forward progression
  *
@@ -15,11 +15,13 @@ import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../../config/featur
  */
 export function isForwardProgression(currentStatus, newStatus) {
     // Any status can transition to archived
-    if (newStatus === 'archived')
+    if (newStatus === 'archived') {
         return true;
+    }
     // Archived can only transition back to backlog (unarchive)
-    if (currentStatus === 'archived')
+    if (currentStatus === 'archived') {
         return newStatus === 'backlog';
+    }
     const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
     const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
     // Allow moving forward or staying at same level (for retries, etc.)

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

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

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

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../../utils/logger.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Get test cases for a feature

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

@@ -1,4 +1,4 @@
-import { FeatureWorkflow } from '../../types/pipeline.js';
+import { type FeatureWorkflow } from '../../types/pipeline.js';
 /**
  * Update feature with new data
  */

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

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../../utils/logger.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Update feature with new data

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

@@ -1,4 +1,4 @@
-import { UserStory, UserStoryStatus } from '../../types/features.js';
+import { type UserStory, type UserStoryStatus } from '../../types/features.js';
 /**
  * Get user stories for a feature
  */

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

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../../utils/logger.js';
+import { logError, logInfo } from '../../utils/logger.js';
 import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Get user stories for a feature

package/dist/api/github.js

@@ -2,8 +2,8 @@
  * GitHub API client for accessing GitHub via MCP server
  * Uses product developer configuration from the database
  */
+import { logDebug, logError, logSuccess, logWarning } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
-import { logDebug, logSuccess, logWarning, logError } from '../utils/logger.js';
 /**
  * Get GitHub developer configuration for a feature
  * Returns installation_id, repository info from product_developers