edsger 0.5.4 → 0.6.1

package/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/steven/development/edsger/**)",
+      "Bash(npm run build)",
+      "Bash(node:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

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

@@ -1,16 +1,16 @@
 /**
  * Batch update user story statuses
  */
-export declare function batchUpdateUserStoryStatus(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+export declare function batchUpdateUserStoryStatus(userStoryIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
 /**
  * Batch update test case statuses
  */
-export declare function batchUpdateTestCaseStatus(mcpServerUrl: string, mcpToken: string, testCaseIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+export declare function batchUpdateTestCaseStatus(testCaseIds: string[], status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
 /**
  * Batch delete user stories
  */
-export declare function batchDeleteUserStories(mcpServerUrl: string, mcpToken: string, userStoryIds: string[], verbose?: boolean): Promise<boolean>;
+export declare function batchDeleteUserStories(userStoryIds: string[], verbose?: boolean): Promise<boolean>;
 /**
  * Batch delete test cases
  */
-export declare function batchDeleteTestCases(mcpServerUrl: string, mcpToken: string, testCaseIds: string[], verbose?: boolean): Promise<boolean>;
+export declare function batchDeleteTestCases(testCaseIds: string[], verbose?: boolean): Promise<boolean>;

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

@@ -3,13 +3,13 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Batch update user story statuses
  */
-export async function batchUpdateUserStoryStatus(mcpServerUrl, mcpToken, userStoryIds, status, verbose) {
+export async function batchUpdateUserStoryStatus(userStoryIds, status, verbose) {
     try {
         if (verbose) {
             logInfo(`Batch updating ${userStoryIds.length} user stories to status: ${status}`);
         }
         for (const id of userStoryIds) {
-            await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/update_status', {
+            await callMcpEndpoint('user_stories/update_status', {
                 user_story_id: id,
                 status,
             });
@@ -28,13 +28,13 @@ export async function batchUpdateUserStoryStatus(mcpServerUrl, mcpToken, userSto
 /**
  * Batch update test case statuses
  */
-export async function batchUpdateTestCaseStatus(mcpServerUrl, mcpToken, testCaseIds, status, verbose) {
+export async function batchUpdateTestCaseStatus(testCaseIds, status, verbose) {
     try {
         if (verbose) {
             logInfo(`Batch updating ${testCaseIds.length} test cases to status: ${status}`);
         }
         for (const id of testCaseIds) {
-            await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/update_status', {
+            await callMcpEndpoint('test_cases/update_status', {
                 test_case_id: id,
                 status,
             });
@@ -53,13 +53,13 @@ export async function batchUpdateTestCaseStatus(mcpServerUrl, mcpToken, testCase
 /**
  * Batch delete user stories
  */
-export async function batchDeleteUserStories(mcpServerUrl, mcpToken, userStoryIds, verbose) {
+export async function batchDeleteUserStories(userStoryIds, verbose) {
     try {
         if (verbose) {
             logInfo(`Batch deleting ${userStoryIds.length} user stories`);
         }
         for (const id of userStoryIds) {
-            await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/delete', {
+            await callMcpEndpoint('user_stories/delete', {
                 user_story_id: id,
             });
         }
@@ -77,13 +77,13 @@ export async function batchDeleteUserStories(mcpServerUrl, mcpToken, userStoryId
 /**
  * Batch delete test cases
  */
-export async function batchDeleteTestCases(mcpServerUrl, mcpToken, testCaseIds, verbose) {
+export async function batchDeleteTestCases(testCaseIds, verbose) {
     try {
         if (verbose) {
             logInfo(`Batch deleting ${testCaseIds.length} test cases`);
         }
         for (const id of testCaseIds) {
-            await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/delete', {
+            await callMcpEndpoint('test_cases/delete', {
                 test_case_id: id,
             });
         }

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

@@ -10,4 +10,4 @@ export declare function sortFeaturesByUpdatedAt(features: FeatureInfo[]): Featur
 /**
  * Get features with ready_for_dev status for a product
  */
-export declare function getReadyForDevFeatures(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<FeatureInfo[]>;
+export declare function getReadyForDevFeatures(productId: string, verbose?: boolean): Promise<FeatureInfo[]>;

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

@@ -19,12 +19,12 @@ export function sortFeaturesByUpdatedAt(features) {
 /**
  * Get features with ready_for_dev status for a product
  */
-export async function getReadyForDevFeatures(mcpServerUrl, mcpToken, productId, verbose) {
+export async function getReadyForDevFeatures(productId, verbose) {
     if (verbose) {
         logInfo(`Fetching ready_for_dev features for product: ${productId}`);
     }
     try {
-        const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/list', {
+        const result = (await callMcpEndpoint('features/list', {
             product_id: productId,
             status: 'ready_for_dev',
         }));

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

@@ -2,4 +2,4 @@ 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>;
+export declare function getFeature(featureId: string, verbose?: boolean): Promise<FeatureInfo>;

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

@@ -3,11 +3,13 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Get feature details by ID
  */
-export async function getFeature(mcpServerUrl, mcpToken, featureId, verbose) {
+export async function getFeature(featureId, verbose) {
     if (verbose) {
         logInfo(`Fetching feature details for: ${featureId}`);
     }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/get', { feature_id: featureId }));
+    const result = (await callMcpEndpoint('features/get', {
+        feature_id: featureId,
+    }));
     if (!result.features || result.features.length === 0) {
         throw new Error(`Feature not found: ${featureId}`);
     }

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

@@ -3,11 +3,7 @@
  * 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 {
+interface StatusUpdateOptions {
     readonly featureId: string;
     readonly status: FeatureStatus;
     readonly verbose?: boolean;
@@ -15,7 +11,7 @@ interface StatusUpdateOptions extends McpClientConfig {
 /**
  * Update feature status via MCP endpoint
  */
-export declare function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
+export declare function updateFeatureStatus({ featureId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
 /**
  * Map pipeline phase to feature status
  */
@@ -23,5 +19,5 @@ 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 declare const updateFeatureStatusForPhase: (featureId: string, phase: string, verbose?: boolean) => Promise<boolean>;
 export {};

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

@@ -7,12 +7,12 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Update feature status via MCP endpoint
  */
-export async function updateFeatureStatus({ mcpServerUrl, mcpToken, featureId, status, verbose = false, }) {
+export async function updateFeatureStatus({ featureId, status, verbose = false, }) {
     try {
         if (verbose) {
             logInfo(`Updating feature ${featureId} status to: ${status}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
+        await callMcpEndpoint('features/update', {
             feature_id: featureId,
             status,
         });
@@ -73,10 +73,9 @@ export const getStatusForPhase = (phase) => {
 /**
  * Update feature status based on pipeline phase
  */
-export const updateFeatureStatusForPhase = (mcpConfig, featureId, phase, verbose) => {
+export const updateFeatureStatusForPhase = (featureId, phase, verbose) => {
     const status = getStatusForPhase(phase);
     return updateFeatureStatus({
-        ...mcpConfig,
         featureId,
         status,
         verbose,

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

@@ -2,11 +2,11 @@ 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[]>;
+export declare function getTestCases(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: {
+export declare function createTestCase(featureId: string, testCase: {
     name: string;
     description: string;
     is_critical?: boolean;
@@ -22,8 +22,8 @@ export declare function createTestCases(mcpServerUrl: string, mcpToken: string,
 /**
  * Delete a test case
  */
-export declare function deleteTestCase(mcpServerUrl: string, mcpToken: string, testCaseId: string, verbose?: boolean): Promise<boolean>;
+export declare function deleteTestCase(testCaseId: string, verbose?: boolean): Promise<boolean>;
 /**
  * Update test case status
  */
-export declare function updateTestCaseStatus(mcpServerUrl: string, mcpToken: string, testCaseId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+export declare function updateTestCaseStatus(testCaseId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;

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

@@ -3,22 +3,24 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Get test cases for a feature
  */
-export async function getTestCases(mcpServerUrl, mcpToken, featureId, verbose) {
+export async function getTestCases(featureId, verbose) {
     if (verbose) {
         logInfo(`Fetching test cases for feature: ${featureId}`);
     }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/list', { feature_id: featureId }));
+    const result = (await callMcpEndpoint('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) {
+export async function createTestCase(featureId, testCase, verbose) {
     try {
         if (verbose) {
             logInfo(`Creating test case for feature: ${featureId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/create', {
+        await callMcpEndpoint('test_cases/create', {
             feature_id: featureId,
             test_cases: [
                 {
@@ -48,7 +50,7 @@ export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCas
             logInfo(`Creating ${testCases.length} test cases for feature: ${featureId}`);
         }
         for (const testCase of testCases) {
-            await createTestCase(mcpServerUrl, mcpToken, featureId, testCase, false);
+            await createTestCase(featureId, testCase, false);
         }
         if (verbose) {
             logInfo('✅ All test cases created successfully');
@@ -64,12 +66,12 @@ export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCas
 /**
  * Delete a test case
  */
-export async function deleteTestCase(mcpServerUrl, mcpToken, testCaseId, verbose) {
+export async function deleteTestCase(testCaseId, verbose) {
     try {
         if (verbose) {
             logInfo(`Deleting test case: ${testCaseId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/delete', {
+        await callMcpEndpoint('test_cases/delete', {
             test_case_id: testCaseId,
         });
         if (verbose) {
@@ -86,12 +88,12 @@ export async function deleteTestCase(mcpServerUrl, mcpToken, testCaseId, verbose
 /**
  * Update test case status
  */
-export async function updateTestCaseStatus(mcpServerUrl, mcpToken, testCaseId, status, verbose) {
+export async function updateTestCaseStatus(testCaseId, status, verbose) {
     try {
         if (verbose) {
             logInfo(`Updating test case ${testCaseId} status to: ${status}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_cases/update_status', {
+        await callMcpEndpoint('test_cases/update_status', {
             test_case_id: testCaseId,
             status,
         });

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

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

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

@@ -3,12 +3,12 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Update feature with new data
  */
-export async function updateFeature(mcpServerUrl, mcpToken, featureId, updates, verbose) {
+export async function updateFeature(featureId, updates, verbose) {
     try {
         if (verbose) {
             logInfo(`Updating feature: ${featureId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'features/update', {
+        await callMcpEndpoint('features/update', {
             feature_id: featureId,
             ...updates,
         });
@@ -26,6 +26,6 @@ export async function updateFeature(mcpServerUrl, mcpToken, featureId, updates,
 /**
  * Update technical design for a feature
  */
-export async function updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, technicalDesign, verbose) {
-    return updateFeature(mcpServerUrl, mcpToken, featureId, { technical_design: technicalDesign }, verbose);
+export async function updateTechnicalDesign(featureId, technicalDesign, verbose) {
+    return updateFeature(featureId, { technical_design: technicalDesign }, verbose);
 }

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

@@ -2,11 +2,11 @@ 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[]>;
+export declare function getUserStories(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: {
+export declare function createUserStory(featureId: string, userStory: {
     title: string;
     description: string;
     status?: string;
@@ -22,8 +22,8 @@ export declare function createUserStories(mcpServerUrl: string, mcpToken: string
 /**
  * Delete a user story
  */
-export declare function deleteUserStory(mcpServerUrl: string, mcpToken: string, userStoryId: string, verbose?: boolean): Promise<boolean>;
+export declare function deleteUserStory(userStoryId: string, verbose?: boolean): Promise<boolean>;
 /**
  * Update user story status
  */
-export declare function updateUserStoryStatus(mcpServerUrl: string, mcpToken: string, userStoryId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;
+export declare function updateUserStoryStatus(userStoryId: string, status: 'draft' | 'ready' | 'in_progress' | 'done' | 'cancelled', verbose?: boolean): Promise<boolean>;

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

@@ -3,22 +3,24 @@ import { callMcpEndpoint } from '../mcp-client.js';
 /**
  * Get user stories for a feature
  */
-export async function getUserStories(mcpServerUrl, mcpToken, featureId, verbose) {
+export async function getUserStories(featureId, verbose) {
     if (verbose) {
         logInfo(`Fetching user stories for feature: ${featureId}`);
     }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/list', { feature_id: featureId }));
+    const result = (await callMcpEndpoint('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) {
+export async function createUserStory(featureId, userStory, verbose) {
     try {
         if (verbose) {
             logInfo(`Creating user story for feature: ${featureId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/create', {
+        await callMcpEndpoint('user_stories/create', {
             feature_id: featureId,
             user_stories: [
                 {
@@ -48,7 +50,7 @@ export async function createUserStories(mcpServerUrl, mcpToken, featureId, userS
             logInfo(`Creating ${userStories.length} user stories for feature: ${featureId}`);
         }
         for (const story of userStories) {
-            await createUserStory(mcpServerUrl, mcpToken, featureId, story, false);
+            await createUserStory(featureId, story, false);
         }
         if (verbose) {
             logInfo('✅ All user stories created successfully');
@@ -64,12 +66,12 @@ export async function createUserStories(mcpServerUrl, mcpToken, featureId, userS
 /**
  * Delete a user story
  */
-export async function deleteUserStory(mcpServerUrl, mcpToken, userStoryId, verbose) {
+export async function deleteUserStory(userStoryId, verbose) {
     try {
         if (verbose) {
             logInfo(`Deleting user story: ${userStoryId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/delete', {
+        await callMcpEndpoint('user_stories/delete', {
             user_story_id: userStoryId,
         });
         if (verbose) {
@@ -86,12 +88,12 @@ export async function deleteUserStory(mcpServerUrl, mcpToken, userStoryId, verbo
 /**
  * Update user story status
  */
-export async function updateUserStoryStatus(mcpServerUrl, mcpToken, userStoryId, status, verbose) {
+export async function updateUserStoryStatus(userStoryId, status, verbose) {
     try {
         if (verbose) {
             logInfo(`Updating user story ${userStoryId} status to: ${status}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'user_stories/update_status', {
+        await callMcpEndpoint('user_stories/update_status', {
             user_story_id: userStoryId,
             status,
         });

package/dist/api/mcp-client.d.ts

@@ -2,16 +2,15 @@
  * Common MCP client utilities for making HTTP requests to MCP servers
  */
 export interface McpRequestOptions {
-    mcpServerUrl: string;
-    mcpToken: string;
     method: string;
     params: unknown;
     verbose?: boolean;
 }
 /**
  * Helper function to make HTTP requests to the MCP server
+ * Reads EDSGER_MCP_SERVER_URL and EDSGER_MCP_TOKEN from environment variables
  */
-export declare function callMcpEndpoint(mcpServerUrl: string, mcpToken: string, method: string, params: unknown): Promise<unknown>;
+export declare function callMcpEndpoint(method: string, params: unknown): Promise<unknown>;
 /**
  * Wrapper for making MCP requests with standardized error handling
  */

package/dist/api/mcp-client.js

@@ -3,8 +3,17 @@
  */
 /**
  * Helper function to make HTTP requests to the MCP server
+ * Reads EDSGER_MCP_SERVER_URL and EDSGER_MCP_TOKEN from environment variables
  */
-export async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
+export async function callMcpEndpoint(method, params) {
+    const mcpServerUrl = process.env.EDSGER_MCP_SERVER_URL;
+    const mcpToken = process.env.EDSGER_MCP_TOKEN;
+    if (!mcpServerUrl) {
+        throw new Error('EDSGER_MCP_SERVER_URL environment variable is not set');
+    }
+    if (!mcpToken) {
+        throw new Error('EDSGER_MCP_TOKEN environment variable is not set');
+    }
     try {
         const response = await fetch(`${mcpServerUrl}/mcp`, {
             method: 'POST',
@@ -37,12 +46,12 @@ export async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
  * Wrapper for making MCP requests with standardized error handling
  */
 export async function makeMcpRequest(options) {
-    const { mcpServerUrl, mcpToken, method, params, verbose } = options;
+    const { method, params, verbose } = options;
     if (verbose) {
         console.log(`Making MCP request: ${method}`);
     }
     try {
-        const result = await callMcpEndpoint(mcpServerUrl, mcpToken, method, params);
+        const result = await callMcpEndpoint(method, params);
         if (verbose) {
             console.log(`MCP request successful: ${method}`);
         }

package/dist/api/products.d.ts

@@ -7,4 +7,4 @@ export interface ProductInfo {
 /**
  * Get product details by ID
  */
-export declare function getProduct(mcpServerUrl: string, mcpToken: string, productId: string, verbose?: boolean): Promise<ProductInfo>;
+export declare function getProduct(productId: string, verbose?: boolean): Promise<ProductInfo>;

package/dist/api/products.js

@@ -3,11 +3,13 @@ import { callMcpEndpoint } from './mcp-client.js';
 /**
  * Get product details by ID
  */
-export async function getProduct(mcpServerUrl, mcpToken, productId, verbose) {
+export async function getProduct(productId, verbose) {
     if (verbose) {
         logInfo(`Fetching product details for: ${productId}`);
     }
-    const result = (await callMcpEndpoint(mcpServerUrl, mcpToken, 'resources/read', { uri: `product://${productId}` }));
+    const result = (await callMcpEndpoint('resources/read', {
+        uri: `product://${productId}`,
+    }));
     const productText = result.contents?.[0]?.text || '{}';
     try {
         return JSON.parse(productText);

package/dist/api/test-reports.js

@@ -8,7 +8,7 @@ export async function createTestReport(mcpServerUrl, mcpToken, featureId, report
         if (verbose) {
             logInfo(`Creating test report for feature: ${featureId}`);
         }
-        await callMcpEndpoint(mcpServerUrl, mcpToken, 'test_reports/create', {
+        await callMcpEndpoint('test_reports/create', {
             feature_id: featureId,
             ...reportData,
         });

package/dist/commands/workflow/config/phase-configs.d.ts

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

package/dist/commands/workflow/config/phase-configs.js

@@ -0,0 +1,98 @@
+/**
+ * Phase configurations for the pipeline runner
+ */
+import { analyseFeature } from '../../../phases/feature-analysis/index.js';
+import { generateTechnicalDesign } from '../../../phases/technical-design/index.js';
+import { implementFeatureCode } from '../../../phases/code-implementation/index.js';
+import { runFunctionalTesting } from '../../../phases/functional-testing/analyzer.js';
+import { writeCodeTests } from '../../../phases/code-testing/analyzer.js';
+import { refineCodeFromPRFeedback } from '../../../phases/code-refine/index.js';
+import { verifyAndResolveComments } from '../../../phases/code-refine-verification/index.js';
+import { reviewPullRequest } from '../../../phases/code-review/index.js';
+/**
+ * Wrapper for code-refine phase to inject GitHub token
+ */
+const executeCodeRefine = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return refineCodeFromPRFeedback({
+        featureId: options.featureId,
+        githubToken,
+        verbose: options.verbose,
+    }, config);
+};
+/**
+ * Wrapper for code-refine-verification phase to inject GitHub token
+ */
+const executeCodeRefineVerification = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return verifyAndResolveComments({
+        featureId: options.featureId,
+        githubToken,
+        config, // Add config parameter for LLM analysis
+        verbose: options.verbose,
+    });
+};
+/**
+ * Wrapper for code-review phase to inject GitHub token
+ */
+const executeCodeReview = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return reviewPullRequest({
+        featureId: options.featureId,
+        githubToken,
+        verbose: options.verbose,
+    }, config);
+};
+// Pipeline phase configurations
+export const phaseConfigs = [
+    {
+        name: 'feature-analysis',
+        execute: analyseFeature,
+    },
+    {
+        name: 'technical-design',
+        execute: generateTechnicalDesign,
+    },
+    {
+        name: 'code-implementation',
+        execute: implementFeatureCode,
+    },
+    {
+        name: 'functional-testing',
+        execute: runFunctionalTesting,
+    },
+    {
+        name: 'code-testing',
+        execute: writeCodeTests,
+    },
+    {
+        name: 'code-refine',
+        execute: executeCodeRefine,
+    },
+    {
+        name: 'code-refine-verification',
+        execute: executeCodeRefineVerification,
+    },
+    {
+        name: 'code-review',
+        execute: executeCodeReview,
+    },
+];

package/dist/commands/workflow/core/feature-filter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Feature filtering utilities for workflow processor
+ * Pure functions for filtering and selecting features for processing
+ */
+import type { FeatureInfo } from '../../../types/features.js';
+import type { FeatureProcessingState } from './state-manager.js';
+export declare const shouldProcessFeature: (maxRetries: number) => (feature: FeatureInfo, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const findNextFeature: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo | undefined;
+export declare const isFeatureProcessing: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const isFeatureCompleted: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const isFeatureFailed: (featureId: string, states: Map<string, FeatureProcessingState>) => boolean;
+export declare const hasReachedMaxRetries: (featureId: string, states: Map<string, FeatureProcessingState>, maxRetries: number) => boolean;
+export declare const filterProcessingFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterCompletedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterFailedFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>) => FeatureInfo[];
+export declare const filterAvailableFeatures: (features: readonly FeatureInfo[], states: Map<string, FeatureProcessingState>, maxRetries: number) => FeatureInfo[];