edsger 0.50.0 → 0.51.0

package/README.md

@@ -1,6 +1,6 @@
 # Edsger
 
-AI-powered software development CLI tool with comprehensive feature management, code review, and testing capabilities using Claude Code SDK and MCP integration.
+AI-powered software development CLI tool with comprehensive issue management, code review, and testing capabilities using Claude Code SDK and MCP integration.
 
 ## Features
 
@@ -26,36 +26,36 @@ AI-powered software development CLI tool with comprehensive feature management,
 - **Improvement Suggestions**: Provides prioritized recommendations for code improvement
 - **Interactive Mode**: Ask for confirmation before applying refactoring changes
 
-### 🎯 Feature Analysis
+### 🎯 Issue Analysis
 
-- **MCP Integration**: Analyze features using Model Context Protocol
-- **User Story Generation**: Create comprehensive user stories for features
+- **MCP Integration**: Analyze issues using Model Context Protocol
+- **User Story Generation**: Create comprehensive user stories for issues
 - **Test Case Creation**: Generate detailed test cases with criticality levels
 - **Deduplication**: Avoid creating similar existing user stories and test cases
 - **Real-time Streaming**: Live analysis feedback with Claude Code SDK
 
 ### 🎨 Technical Design
 
-- **Design Generation**: Create technical specifications for features
+- **Design Generation**: Create technical specifications for issues
 - **Architecture Planning**: Generate implementation roadmaps and technical details
 - **Integration Support**: Works with MCP for structured design output
 
 ### 💻 Code Implementation
 
-- **Feature Implementation**: Automatically implement features based on specifications
+- **Issue Implementation**: Automatically implement issues based on specifications
 - **Branch Management**: Creates feature branches and manages git workflow
 - **Code Generation**: AI-powered code writing with proper git integration
 
 ### 🎭 Functional Testing
 
-- **Automated Testing**: Run Playwright-based functional tests for features
+- **Automated Testing**: Run Playwright-based functional tests for issues
 - **Test Execution**: Execute test cases with detailed reporting
 - **Status Tracking**: Monitor test results with pass/fail statistics
 
 ### 🚀 Workflow Management
 
-- **Continuous Processing**: Monitor and process features ready for development
-- **End-to-End Automation**: Complete feature lifecycle from analysis to testing
+- **Continuous Processing**: Monitor and process issues ready for development
+- **End-to-End Automation**: Complete issue lifecycle from analysis to testing
 - **Real-time Monitoring**: Live workflow processing with statistics and graceful shutdown
 
 ## Installation
@@ -120,44 +120,44 @@ edsger --refactor
 edsger --refactor --verbose
 ```
 
-### Feature Analysis
+### Issue Analysis
 
 ```bash
-# Analyze a feature and generate user stories/test cases
-edsger --feature-analysis <feature-id>
+# Analyze an issue and generate user stories/test cases
+edsger --issue-analysis <issue-id>
 
 # Verbose analysis output
-edsger --feature-analysis <feature-id> --verbose
+edsger --issue-analysis <issue-id> --verbose
 ```
 
 ### Technical Design
 
 ```bash
-# Generate technical design for a feature
-edsger --technical-design <feature-id>
+# Generate technical design for an issue
+edsger --technical-design <issue-id>
 
 # Verbose design output
-edsger --technical-design <feature-id> --verbose
+edsger --technical-design <issue-id> --verbose
 ```
 
 ### Code Implementation
 
 ```bash
-# Implement feature code based on specifications
-edsger --implement <feature-id>
+# Implement issue code based on specifications
+edsger --implement <issue-id>
 
 # Verbose implementation output
-edsger --implement <feature-id> --verbose
+edsger --implement <issue-id> --verbose
 ```
 
 ### Functional Testing
 
 ```bash
-# Run functional tests for a feature
-edsger --test <feature-id>
+# Run functional tests for an issue
+edsger --test <issue-id>
 
 # Verbose test output
-edsger --test <feature-id> --verbose
+edsger --test <issue-id> --verbose
 ```
 
 ### Workflow Management
@@ -198,9 +198,9 @@ Create a configuration file (`.edsgerrc.json`, `edsger.config.js`, etc.):
 
 ## Environment Variables
 
-### Required for Advanced Features (Feature Analysis, Technical Design, Implementation, Testing, Workflow)
+### Required for Advanced Features (Issue Analysis, Technical Design, Implementation, Testing, Workflow)
 
-- `EDSGER_MCP_SERVER_URL`: MCP server URL for feature operations
+- `EDSGER_MCP_SERVER_URL`: MCP server URL for issue operations
 - `EDSGER_MCP_TOKEN`: Required authentication token for MCP server
 - `EDSGER_PRODUCT_ID`: Product ID for workflow management (optional for workflow mode)
 
@@ -226,7 +226,7 @@ npx edsger --review --staged
 
 - Node.js >= 18.0.0
 - `@anthropic-ai/claude-code` SDK
-- MCP server for advanced feature operations (analysis, design, implementation, testing)
+- MCP server for advanced issue operations (analysis, design, implementation, testing)
 - Playwright for functional testing (when using `--test` flag)
 
 ## License

package/dist/api/chat.d.ts

@@ -52,20 +52,20 @@ export declare function sendProductAiMessage(productId: string, content: string,
     parentMessageId?: string;
 }, verbose?: boolean): Promise<ChatMessage>;
 /**
- * Get or create the group chat channel for a feature.
- * This is the most common operation — every feature has one group channel.
+ * Get or create the group chat channel for an issue.
+ * This is the most common operation — every issue has one group channel.
  */
-export declare function getFeatureChannel(featureId: string, verbose?: boolean): Promise<ChatChannel>;
+export declare function getIssueChannel(issueId: string, verbose?: boolean): Promise<ChatChannel>;
 /**
- * Send a system message to a feature's group channel.
+ * Send a system message to an issue's group channel.
  * Creates the channel if it doesn't exist.
  */
-export declare function sendFeatureSystemMessage(featureId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
+export declare function sendIssueSystemMessage(issueId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
 /**
- * Send an AI message to a feature's group channel.
+ * Send an AI message to an issue's group channel.
  * Creates the channel if it doesn't exist.
  */
-export declare function sendFeatureAiMessage(featureId: string, content: string, metadata?: Record<string, unknown>, options?: {
+export declare function sendIssueAiMessage(issueId: string, content: string, metadata?: Record<string, unknown>, options?: {
     messageType?: ChatMessageType;
     parentMessageId?: string;
 }, verbose?: boolean): Promise<ChatMessage>;

package/dist/api/chat.js

@@ -176,43 +176,43 @@ export async function sendProductAiMessage(productId, content, metadata = {}, op
     }
 }
 // ============================================================
-// Convenience: Feature Channel
+// Convenience: Issue Channel
 // ============================================================
 /**
- * Get or create the group chat channel for a feature.
- * This is the most common operation — every feature has one group channel.
+ * Get or create the group chat channel for an issue.
+ * This is the most common operation — every issue has one group channel.
  */
-export async function getFeatureChannel(featureId, verbose) {
-    const { channel } = await getOrCreateChannel('feature', featureId, 'group', undefined, verbose);
+export async function getIssueChannel(issueId, verbose) {
+    const { channel } = await getOrCreateChannel('issue', issueId, 'group', undefined, verbose);
     return channel;
 }
 /**
- * Send a system message to a feature's group channel.
+ * Send a system message to an issue's group channel.
  * Creates the channel if it doesn't exist.
  */
-export async function sendFeatureSystemMessage(featureId, content, metadata = {}, verbose) {
+export async function sendIssueSystemMessage(issueId, content, metadata = {}, verbose) {
     try {
-        const channel = await getFeatureChannel(featureId, verbose);
+        const channel = await getIssueChannel(issueId, verbose);
         return await sendSystemMessage(channel.id, content, metadata, verbose);
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        logError(`Failed to send system message for feature ${featureId}: ${msg}`);
+        logError(`Failed to send system message for issue ${issueId}: ${msg}`);
         throw error;
     }
 }
 /**
- * Send an AI message to a feature's group channel.
+ * Send an AI message to an issue's group channel.
  * Creates the channel if it doesn't exist.
  */
-export async function sendFeatureAiMessage(featureId, content, metadata = {}, options = {}, verbose) {
+export async function sendIssueAiMessage(issueId, content, metadata = {}, options = {}, verbose) {
     try {
-        const channel = await getFeatureChannel(featureId, verbose);
+        const channel = await getIssueChannel(issueId, verbose);
         return await sendAiMessage(channel.id, content, metadata, options, verbose);
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        logError(`Failed to send AI message for feature ${featureId}: ${msg}`);
+        logError(`Failed to send AI message for issue ${issueId}: ${msg}`);
         throw error;
     }
 }

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

@@ -1,18 +1,18 @@
 /**
- * Cross-product API - Fetch features across all products
+ * Cross-product API - Fetch issues across all products
  *
  * Used in the new default mode (agent workflow) where the CLI
- * processes features from all products the user has access to,
+ * processes issues from all products the user has access to,
  * not just a single product.
  */
-import { type FeatureInfo } from '../types/features.js';
+import { type IssueInfo } from '../types/issues.js';
 export interface ProductSummary {
     id: string;
     name: string;
     description?: string;
     status?: string;
 }
-export interface FeatureWithProduct extends FeatureInfo {
+export interface IssueWithProduct extends IssueInfo {
     product_name?: string;
 }
 /**
@@ -20,12 +20,12 @@ export interface FeatureWithProduct extends FeatureInfo {
  */
 export declare function listProducts(verbose?: boolean): Promise<ProductSummary[]>;
 /**
- * List all ready_for_ai features across all products
- * Iterates through all accessible products and collects their features
+ * List all ready_for_ai issues across all products
+ * Iterates through all accessible products and collects their issues
  */
-export declare function listAllReadyFeatures(verbose?: boolean): Promise<FeatureWithProduct[]>;
+export declare function listAllReadyIssues(verbose?: boolean): Promise<IssueWithProduct[]>;
 /**
- * Claim a specific feature for processing
- * Unlike the product-level claim, this claims a specific feature by ID
+ * Claim a specific issue for processing
+ * Unlike the product-level claim, this claims a specific issue by ID
  */
-export declare function claimFeatureById(featureId: string, productId: string, verbose?: boolean): Promise<FeatureInfo | null>;
+export declare function claimIssueById(issueId: string, productId: string, verbose?: boolean): Promise<IssueInfo | null>;

package/dist/api/cross-product.js

@@ -1,8 +1,8 @@
 /**
- * Cross-product API - Fetch features across all products
+ * Cross-product API - Fetch issues across all products
  *
  * Used in the new default mode (agent workflow) where the CLI
- * processes features from all products the user has access to,
+ * processes issues from all products the user has access to,
  * not just a single product.
  */
 import { logError, logInfo } from '../utils/logger.js';
@@ -28,12 +28,12 @@ export async function listProducts(verbose) {
     }
 }
 /**
- * List all ready_for_ai features across all products
- * Iterates through all accessible products and collects their features
+ * List all ready_for_ai issues across all products
+ * Iterates through all accessible products and collects their issues
  */
-export async function listAllReadyFeatures(verbose) {
+export async function listAllReadyIssues(verbose) {
     if (verbose) {
-        logInfo('Fetching ready_for_ai features across all products...');
+        logInfo('Fetching ready_for_ai issues across all products...');
     }
     try {
         // First, get all products
@@ -44,68 +44,68 @@ export async function listAllReadyFeatures(verbose) {
             }
             return [];
         }
-        // Fetch ready_for_ai features for all products in parallel
-        const featureResults = await Promise.allSettled(products.map(async (product) => {
-            const result = (await callMcpEndpoint('features/list', {
+        // Fetch ready_for_ai issues for all products in parallel
+        const issueResults = await Promise.allSettled(products.map(async (product) => {
+            const result = (await callMcpEndpoint('issues/list', {
                 product_id: product.id,
                 status: 'ready_for_ai',
             }));
-            return (result.features || []).map((feature) => ({
-                ...feature,
+            return (result.issues || []).map((issue) => ({
+                ...issue,
                 product_name: product.name,
             }));
         }));
-        const allFeatures = [];
-        featureResults.forEach((result, i) => {
+        const allIssues = [];
+        issueResults.forEach((result, i) => {
             if (result.status === 'fulfilled') {
-                allFeatures.push(...result.value);
+                allIssues.push(...result.value);
             }
             else if (verbose) {
-                logInfo(`Could not fetch features for product: ${products[i].name}`);
+                logInfo(`Could not fetch issues for product: ${products[i].name}`);
             }
         });
         // Sort by updated_at (oldest first)
-        allFeatures.sort((a, b) => {
+        allIssues.sort((a, b) => {
             const dateA = new Date(a.updated_at || 0).getTime();
             const dateB = new Date(b.updated_at || 0).getTime();
             return dateA - dateB;
         });
         if (verbose) {
-            logInfo(`Found ${allFeatures.length} ready_for_ai feature(s) across ${products.length} product(s)`);
-            allFeatures.forEach((f, i) => {
+            logInfo(`Found ${allIssues.length} ready_for_ai issue(s) across ${products.length} product(s)`);
+            allIssues.forEach((f, i) => {
                 logInfo(`  ${i + 1}. [${f.product_name}] ${f.name}`);
             });
         }
-        return allFeatures;
+        return allIssues;
     }
     catch (error) {
-        logError(`Failed to list features: ${error instanceof Error ? error.message : String(error)}`);
+        logError(`Failed to list issues: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }
 /**
- * Claim a specific feature for processing
- * Unlike the product-level claim, this claims a specific feature by ID
+ * Claim a specific issue for processing
+ * Unlike the product-level claim, this claims a specific issue by ID
  */
-export async function claimFeatureById(featureId, productId, verbose) {
+export async function claimIssueById(issueId, productId, verbose) {
     if (verbose) {
-        logInfo(`Claiming feature: ${featureId}`);
+        logInfo(`Claiming issue: ${issueId}`);
     }
     try {
-        const result = (await callMcpEndpoint('features/claim', {
+        const result = (await callMcpEndpoint('issues/claim', {
             product_id: productId,
-            feature_id: featureId,
+            issue_id: issueId,
         }));
-        if (result.feature) {
+        if (result.issue) {
             if (verbose) {
-                logInfo(`Claimed feature: ${result.feature.name}`);
+                logInfo(`Claimed issue: ${result.issue.name}`);
             }
-            return result.feature;
+            return result.issue;
         }
         return null;
     }
     catch (error) {
-        logError(`Failed to claim feature: ${error instanceof Error ? error.message : String(error)}`);
+        logError(`Failed to claim issue: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/dist/api/github.d.ts

@@ -31,16 +31,16 @@ export interface GitHubConfigAndToken {
     expires_at?: string;
 }
 /**
- * Get GitHub developer configuration for a feature
+ * Get GitHub developer configuration for an issue
  * Returns installation_id, repository info from product_developers
  */
-export declare function getGitHubDeveloperConfig(featureId: string, verbose?: boolean): Promise<GitHubDeveloperConfig>;
+export declare function getGitHubDeveloperConfig(issueId: string, verbose?: boolean): Promise<GitHubDeveloperConfig>;
 /**
  * Get installation access token for GitHub API operations
  */
-export declare function getGitHubInstallationToken(installationId: number, featureId: string, verbose?: boolean): Promise<GitHubInstallationToken | null>;
+export declare function getGitHubInstallationToken(installationId: number, issueId: string, verbose?: boolean): Promise<GitHubInstallationToken | null>;
 /**
- * Get GitHub config and token by product ID (no feature required).
+ * Get GitHub config and token by product ID (no issue required).
  * Used for product-level operations like growth analysis.
  */
 export declare function getGitHubConfigByProduct(productId: string, verbose?: boolean): Promise<{
@@ -54,7 +54,7 @@ export declare function getGitHubConfigByProduct(productId: string, verbose?: bo
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config
  */
-export declare function getGitHubConfig(featureId: string, verbose?: boolean): Promise<{
+export declare function getGitHubConfig(issueId: string, verbose?: boolean): Promise<{
     configured: boolean;
     token?: string;
     owner?: string;

package/dist/api/github.js

@@ -5,14 +5,14 @@
 import { logDebug, logError, logSuccess, logWarning } from '../utils/logger.js';
 import { callMcpEndpoint } from './mcp-client.js';
 /**
- * Get GitHub developer configuration for a feature
+ * Get GitHub developer configuration for an issue
  * Returns installation_id, repository info from product_developers
  */
-export async function getGitHubDeveloperConfig(featureId, verbose) {
-    logDebug(`Fetching GitHub developer config for feature: ${featureId}`, verbose);
+export async function getGitHubDeveloperConfig(issueId, verbose) {
+    logDebug(`Fetching GitHub developer config for issue: ${issueId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/developer_config', {
-            feature_id: featureId,
+            issue_id: issueId,
         }));
         if (verbose) {
             if (result.configured) {
@@ -37,12 +37,12 @@ export async function getGitHubDeveloperConfig(featureId, verbose) {
 /**
  * Get installation access token for GitHub API operations
  */
-export async function getGitHubInstallationToken(installationId, featureId, verbose) {
+export async function getGitHubInstallationToken(installationId, issueId, verbose) {
     logDebug(`Fetching GitHub installation token for: ${installationId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/installation_token', {
             installation_id: installationId,
-            feature_id: featureId,
+            issue_id: issueId,
         }));
         if (verbose) {
             logSuccess(`GitHub token obtained, expires: ${result.expires_at}`);
@@ -57,7 +57,7 @@ export async function getGitHubInstallationToken(installationId, featureId, verb
     }
 }
 /**
- * Get GitHub config and token by product ID (no feature required).
+ * Get GitHub config and token by product ID (no issue required).
  * Used for product-level operations like growth analysis.
  */
 export async function getGitHubConfigByProduct(productId, verbose) {
@@ -102,11 +102,11 @@ export async function getGitHubConfigByProduct(productId, verbose) {
  * Get GitHub config and token in one call
  * This is the main entry point for getting GitHub config
  */
-export async function getGitHubConfig(featureId, verbose) {
-    logDebug(`Fetching GitHub config for feature: ${featureId}`, verbose);
+export async function getGitHubConfig(issueId, verbose) {
+    logDebug(`Fetching GitHub config for issue: ${issueId}`, verbose);
     try {
         const result = (await callMcpEndpoint('github/config_and_token', {
-            feature_id: featureId,
+            issue_id: issueId,
         }));
         if (verbose) {
             if (result.configured) {

package/dist/api/intelligence.d.ts

@@ -19,7 +19,7 @@ export interface CompetitorSnapshot {
     id: string;
     competitor_id: string;
     product_id: string;
-    features: {
+    issues: {
         name: string;
         description: string;
         is_new?: boolean;
@@ -28,7 +28,7 @@ export interface CompetitorSnapshot {
         tiers?: {
             name: string;
             price: string;
-            features: string[];
+            issues: string[];
         }[];
         model?: string;
     };
@@ -133,7 +133,7 @@ export declare function getSnapshots(opts: {
 export declare function saveSnapshot(snapshot: {
     competitor_id: string;
     product_id: string;
-    features?: unknown[];
+    issues?: unknown[];
     pricing?: unknown;
     tech_stack?: unknown[];
     app_rating?: number;

package/dist/api/issues/approval-checker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Approval workflow integration for issue phases
+ * Checks if current issue status has been approved before executing next phase
+ */
+interface ApprovalCheckResult {
+    canProceed: boolean;
+    requiresApproval: boolean;
+    approvalId?: string;
+    message?: string;
+}
+/**
+ * Check if current issue status has been approved before executing next phase
+ * This should be called BEFORE executing a phase, not after
+ *
+ * @param issueId - Issue ID
+ * @param verbose - Verbose logging
+ * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
+ */
+export declare function checkApprovalBeforePhaseExecution(issueId: string, verbose?: boolean): Promise<ApprovalCheckResult>;
+export {};