edsger 0.50.0 → 0.52.0

package/dist/utils/git-branch-manager.js

@@ -350,34 +350,34 @@ export function pullLatestFromBranch(branch, verbose, githubToken) {
     }
 }
 /**
- * Switch to feature branch and rebase with main
+ * Switch to issue branch and rebase with main
  * This should be called at the START of each phase
  *
- * @param featureBranch - The feature branch to switch to (e.g., "dev/feature-id")
+ * @param issueBranch - The issue branch to switch to (e.g., "dev/issue-id")
  * @param baseBranch - The base branch to rebase from (usually "main")
  * @param verbose - Whether to log verbose output
  * @returns Object containing the previous branch name
  */
 // eslint-disable-next-line complexity -- git branch management with rebase, conflict handling, and fallback strategies
-export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main', verbose, githubToken) {
+export function switchToIssueBranchAndRebase(issueBranch, baseBranch = 'main', verbose, githubToken) {
     const previousBranch = getCurrentBranch();
     if (verbose) {
-        logInfo(`\n🔄 Preparing feature branch: ${featureBranch}`);
+        logInfo(`\n🔄 Preparing issue branch: ${issueBranch}`);
         logInfo(`   Current branch: ${previousBranch}`);
     }
-    // If feature branch doesn't exist, we need to create it from base branch
-    if (!branchExists(featureBranch)) {
+    // If issue branch doesn't exist, we need to create it from base branch
+    if (!branchExists(issueBranch)) {
         if (verbose) {
-            logInfo(`   Feature branch ${featureBranch} doesn't exist, will create from ${baseBranch}`);
+            logInfo(`   Issue branch ${issueBranch} doesn't exist, will create from ${baseBranch}`);
         }
-        // First, ensure we're on the base branch to create feature branch from it
+        // First, ensure we're on the base branch to create issue branch from it
         if (previousBranch !== baseBranch) {
             if (verbose) {
                 logInfo(`   Switching to ${baseBranch} first...`);
             }
             switchToBranch(baseBranch, verbose);
         }
-        // Pull latest base branch before creating feature branch
+        // Pull latest base branch before creating issue branch
         try {
             if (verbose) {
                 logInfo(`   Pulling latest ${baseBranch}...`);
@@ -390,12 +390,12 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
             }
         }
     }
-    // Switch to feature branch (will create if doesn't exist)
+    // Switch to issue branch (will create if doesn't exist)
     // Default behavior now checks remote first (handles multi-clone scenarios)
-    if (getCurrentBranch() !== featureBranch) {
-        switchToBranch(featureBranch, verbose, { githubToken });
+    if (getCurrentBranch() !== issueBranch) {
+        switchToBranch(issueBranch, verbose, { githubToken });
     }
-    // Sync with remote feature branch if it exists and local branch needs updating
+    // Sync with remote issue branch if it exists and local branch needs updating
     // This handles the case where local branch exists but is behind remote
     try {
         // Check for uncommitted changes and reset if found before any git operations
@@ -411,58 +411,58 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
             encoding: 'utf-8',
             stdio: 'pipe',
         });
-        // Check if remote feature branch exists
+        // Check if remote issue branch exists
         try {
-            execSync(`git rev-parse --verify origin/${featureBranch}`, {
+            execSync(`git rev-parse --verify origin/${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
             // Remote branch exists, check if we need to sync
             // Get local and remote commit SHAs
-            const localSha = execSync(`git rev-parse ${featureBranch}`, {
+            const localSha = execSync(`git rev-parse ${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             }).trim();
-            const remoteSha = execSync(`git rev-parse origin/${featureBranch}`, {
+            const remoteSha = execSync(`git rev-parse origin/${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             }).trim();
             if (localSha !== remoteSha) {
                 // Local and remote differ, reset to remote
                 if (verbose) {
-                    logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+                    logInfo(`📥 Syncing with remote issue branch origin/${issueBranch}...`);
                     logInfo(`   Local:  ${localSha.substring(0, 7)}`);
                     logInfo(`   Remote: ${remoteSha.substring(0, 7)}`);
                 }
                 // Reset local branch to match remote branch
                 // This ensures we have all commits from the remote (e.g., from another machine)
-                execSync(`git reset --hard origin/${featureBranch}`, {
+                execSync(`git reset --hard origin/${issueBranch}`, {
                     encoding: 'utf-8',
                     stdio: 'pipe',
                 });
                 if (verbose) {
-                    logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+                    logInfo(`✅ Synced local branch with origin/${issueBranch}`);
                 }
             }
             else if (verbose) {
-                logInfo(`✅ Local branch is up to date with origin/${featureBranch}`);
+                logInfo(`✅ Local branch is up to date with origin/${issueBranch}`);
             }
         }
         catch (_e) {
             // Remote branch doesn't exist, that's fine - we'll push later
             if (verbose) {
-                logInfo(`   Remote branch origin/${featureBranch} doesn't exist yet, will create on push`);
+                logInfo(`   Remote branch origin/${issueBranch} doesn't exist yet, will create on push`);
             }
         }
     }
     catch (_error) {
         if (verbose) {
-            logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
+            logInfo(`⚠️  Could not sync with remote issue branch, continuing with local branch`);
         }
     }
-    // Rebase feature branch with latest main
+    // Rebase issue branch with latest main
     if (verbose) {
-        logInfo(`📥 Rebasing ${featureBranch} with origin/${baseBranch}...`);
+        logInfo(`📥 Rebasing ${issueBranch} with origin/${baseBranch}...`);
     }
     try {
         // Check for uncommitted changes and reset if found
@@ -478,7 +478,7 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
             stdio: verbose ? 'inherit' : 'pipe',
         });
         if (verbose) {
-            logInfo(`✅ Successfully rebased ${featureBranch} with origin/${baseBranch}\n`);
+            logInfo(`✅ Successfully rebased ${issueBranch} with origin/${baseBranch}\n`);
         }
     }
     catch (error) {
@@ -492,8 +492,8 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
         catch (_abortError) {
             // Rebase abort failed or wasn't needed, that's okay
         }
-        throw new Error(`Failed to rebase ${featureBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}\n` +
-            `This usually means there are conflicts between your feature branch and main branch.\n` +
+        throw new Error(`Failed to rebase ${issueBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}\n` +
+            `This usually means there are conflicts between your issue branch and main branch.\n` +
             `Please resolve conflicts manually and try again.`);
     }
     return { previousBranch };
@@ -523,7 +523,7 @@ export function returnToMainBranch(baseBranch = 'main', verbose) {
             logError(`   Resetting uncommitted changes to allow branch switch.`);
         }
         // Reset uncommitted changes to allow clean branch switch
-        // The code should already be committed on the feature branch,
+        // The code should already be committed on the issue branch,
         // so these changes are likely from post-commit operations
         resetUncommittedChanges(verbose);
     }
@@ -533,9 +533,9 @@ export function returnToMainBranch(baseBranch = 'main', verbose) {
     }
 }
 /**
- * Full phase lifecycle: switch to feature branch, rebase with main, and return a cleanup function
+ * Full phase lifecycle: switch to issue branch, rebase with main, and return a cleanup function
  * Usage:
- *   const cleanup = preparePhaseGitEnvironment(featureId, baseBranch, verbose)
+ *   const cleanup = preparePhaseGitEnvironment(issueId, baseBranch, verbose)
  *   try {
  *     // ... phase logic ...
  *   } finally {
@@ -546,18 +546,18 @@ export function returnToMainBranch(baseBranch = 'main', verbose) {
  * is in a clean state (rebase aborted). The caller should still call the cleanup function
  * in a finally block to return to the main branch.
  *
- * @param featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
  * @param baseBranch - The base branch to rebase from (default: "main")
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export function preparePhaseGitEnvironment(featureId, baseBranch = 'main', verbose) {
-    const featureBranch = `dev/${featureId}`;
-    return prepareCustomBranchGitEnvironment(featureBranch, baseBranch, verbose);
+export function preparePhaseGitEnvironment(issueId, baseBranch = 'main', verbose) {
+    const issueBranch = `dev/${issueId}`;
+    return prepareCustomBranchGitEnvironment(issueBranch, baseBranch, verbose);
 }
 /**
  * Full phase lifecycle with custom branch names for branch chaining support.
- * This allows creating a feature branch from another feature branch (not just main).
+ * This allows creating a issue branch from another issue branch (not just main).
  *
  * Usage:
  *   const cleanup = prepareCustomBranchGitEnvironment('feat/123/2-api', 'feat/123/1-database', verbose)
@@ -567,20 +567,20 @@ export function preparePhaseGitEnvironment(featureId, baseBranch = 'main', verbo
  *     cleanup()
  *   }
  *
- * @param featureBranch - The feature branch to switch to (e.g., "feat/123/2-api")
+ * @param issueBranch - The issue branch to switch to (e.g., "feat/123/2-api")
  * @param baseBranch - The base branch to rebase from (e.g., "main" or "feat/123/1-database")
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export function prepareCustomBranchGitEnvironment(featureBranch, baseBranch = 'main', verbose) {
+export function prepareCustomBranchGitEnvironment(issueBranch, baseBranch = 'main', verbose) {
     // Create cleanup function BEFORE any operations that might fail
-    // This ensures cleanup can be called even if switchToFeatureBranchAndRebase throws
+    // This ensures cleanup can be called even if switchToIssueBranchAndRebase throws
     const cleanup = () => {
         returnToMainBranch('main', verbose); // Always return to main, not the baseBranch
     };
     try {
-        // Switch to feature branch and rebase with base branch
-        switchToFeatureBranchAndRebase(featureBranch, baseBranch, verbose);
+        // Switch to issue branch and rebase with base branch
+        switchToIssueBranchAndRebase(issueBranch, baseBranch, verbose);
     }
     catch (error) {
         // If setup fails, try to cleanup before re-throwing
@@ -600,4 +600,4 @@ export function prepareCustomBranchGitEnvironment(featureBranch, baseBranch = 'm
     return cleanup;
 }
 // Re-export async operations from separate file for backward compatibility
-export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, switchToFeatureBranchAndRebaseAsync, syncFeatBranchWithMain, } from './git-branch-manager-async.js';
+export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, switchToIssueBranchAndRebaseAsync, syncFeatBranchWithMain, } from './git-branch-manager-async.js';

package/dist/utils/image-downloader.d.ts

@@ -7,10 +7,10 @@ export interface DownloadedImage {
     alt: string;
 }
 /**
- * Set current feature ID for image downloads
+ * Set current issue ID for image downloads
  * Should be called at the start of pipeline execution
  */
-export declare function setCurrentFeatureId(featureId: string): void;
+export declare function setCurrentIssueId(issueId: string): void;
 /**
  * Reset image cache (useful for testing)
  */
@@ -20,9 +20,9 @@ export declare function resetImageCache(): void;
  * Uses cache to avoid downloading same image multiple times
  *
  * @param markdown - Markdown content with image URLs
- * @param featureId - Feature ID for directory naming
+ * @param issueId - Issue ID for directory naming
  */
-export declare function downloadImagesForClaudeCode(markdown: string, featureId?: string): Promise<{
+export declare function downloadImagesForClaudeCode(markdown: string, issueId?: string): Promise<{
     processedMarkdown: string;
     downloadedImages: DownloadedImage[];
 }>;

package/dist/utils/image-downloader.js

@@ -30,8 +30,8 @@ function detectImageExtension(url, contentType) {
 // Cache for downloaded images in current session
 // Key: image URL, Value: local path
 const imageCache = new Map();
-// Current feature ID for directory naming
-let currentFeatureId = null;
+// Current issue ID for directory naming
+let currentIssueId = null;
 /**
  * Generate hash from URL to use as filename
  * This ensures same URL always maps to same file
@@ -40,20 +40,20 @@ function hashUrl(url) {
     return createHash('md5').update(url).digest('hex');
 }
 /**
- * Get or create temp directory for current feature
+ * Get or create temp directory for current issue
  */
-function getTempDir(featureId) {
-    return join(tmpdir(), 'claude-code-images', `feature-${featureId}`);
+function getTempDir(issueId) {
+    return join(tmpdir(), 'claude-code-images', `issue-${issueId}`);
 }
 /**
- * Set current feature ID for image downloads
+ * Set current issue ID for image downloads
  * Should be called at the start of pipeline execution
  */
-export function setCurrentFeatureId(featureId) {
-    if (currentFeatureId !== featureId) {
-        // Clear cache when switching to different feature
+export function setCurrentIssueId(issueId) {
+    if (currentIssueId !== issueId) {
+        // Clear cache when switching to different issue
         imageCache.clear();
-        currentFeatureId = featureId;
+        currentIssueId = issueId;
     }
 }
 /**
@@ -61,29 +61,29 @@ export function setCurrentFeatureId(featureId) {
  */
 export function resetImageCache() {
     imageCache.clear();
-    currentFeatureId = null;
+    currentIssueId = null;
 }
 /**
  * Download images from URLs to temporary directory for Claude Code to read
  * Uses cache to avoid downloading same image multiple times
  *
  * @param markdown - Markdown content with image URLs
- * @param featureId - Feature ID for directory naming
+ * @param issueId - Issue ID for directory naming
  */
-export async function downloadImagesForClaudeCode(markdown, featureId) {
+export async function downloadImagesForClaudeCode(markdown, issueId) {
     if (!markdown) {
         return { processedMarkdown: markdown, downloadedImages: [] };
     }
-    // Use provided featureId or fall back to currentFeatureId or timestamp
-    const effectiveFeatureId = featureId || currentFeatureId || Date.now().toString();
+    // Use provided issueId or fall back to currentIssueId or timestamp
+    const effectiveIssueId = issueId || currentIssueId || Date.now().toString();
     // Extract all image URLs from markdown
     const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)(?:\{width=\d+\})?/g;
     const matches = Array.from(markdown.matchAll(imageRegex));
     if (matches.length === 0) {
         return { processedMarkdown: markdown, downloadedImages: [] };
     }
-    // Create temp directory for this feature
-    const tempDir = getTempDir(effectiveFeatureId);
+    // Create temp directory for this issue
+    const tempDir = getTempDir(effectiveIssueId);
     await mkdir(tempDir, { recursive: true });
     const downloadedImages = [];
     let processedMarkdown = markdown;

package/dist/utils/pipeline-logger.d.ts

@@ -2,7 +2,7 @@
  * Logging utilities for pipeline execution
  */
 import { type PipelineResult } from '../types/pipeline.js';
-export declare const logPipelineStart: (featureId: string, verbose?: boolean) => void;
+export declare const logPipelineStart: (issueId: string, verbose?: boolean) => void;
 export declare const logPhaseResult: (result: PipelineResult, verbose?: boolean) => PipelineResult;
 export declare const logPipelineComplete: (results: readonly PipelineResult[], verbose?: boolean) => readonly PipelineResult[];
 export declare const shouldContinuePipeline: (results: readonly PipelineResult[]) => boolean;

package/dist/utils/pipeline-logger.js

@@ -3,9 +3,9 @@
  */
 import { logDebug, logError, logSuccess } from './logger.js';
 // Pipeline execution utilities
-export const logPipelineStart = (featureId, verbose) => {
-    logDebug(`Starting complete pipeline for feature: ${featureId}`, verbose);
-    logDebug('Pipeline phases: feature-analysis → technical-design → code-implementation → functional-testing', verbose);
+export const logPipelineStart = (issueId, verbose) => {
+    logDebug(`Starting complete pipeline for issue: ${issueId}`, verbose);
+    logDebug('Pipeline phases: issue-analysis → technical-design → code-implementation → functional-testing', verbose);
 };
 export const logPhaseResult = (result, verbose) => {
     if (verbose) {
@@ -21,9 +21,9 @@ export const logPhaseResult = (result, verbose) => {
 export const logPipelineComplete = (results, verbose) => {
     if (verbose) {
         const lastResult = results[results.length - 1];
-        const featureId = lastResult?.featureId;
+        const issueId = lastResult?.issueId;
         if (lastResult?.status === 'success') {
-            logSuccess(`Complete pipeline finished successfully for feature: ${featureId}`);
+            logSuccess(`Complete pipeline finished successfully for issue: ${issueId}`);
         }
         else {
             logError(`Pipeline failed at ${lastResult?.phase}: ${lastResult?.message}`);

package/dist/workspace/workspace-manager.d.ts

@@ -1,17 +1,17 @@
 /**
- * Workspace Manager - Manages the edsger working directory and feature repos
+ * Workspace Manager - Manages the edsger working directory and issue repos
  *
  * Handles:
  * - Detecting or creating the 'edsger' working directory
  * - Cloning repos using GitHub App installation tokens
- * - Using feature ID as directory name for cloned repos
- * - Reusing existing cloned repos for the same feature
+ * - Using issue ID as directory name for cloned repos
+ * - Reusing existing cloned repos for the same issue
  */
 export interface WorkspaceConfig {
     /** Root workspace directory path */
     rootDir: string;
 }
-export interface FeatureRepo {
+export interface IssueRepo {
     /** Path to the cloned repo directory */
     repoPath: string;
     /** Whether the repo was freshly cloned (vs reused) */
@@ -30,28 +30,28 @@ export declare function getWorkspaceRoot(): string;
  */
 export declare function ensureWorkspaceDir(): string;
 /**
- * Get the directory path for a feature's repo clone
- * Uses the feature ID as the directory name
+ * Get the directory path for an issue's repo clone
+ * Uses the issue ID as the directory name
  */
-export declare function getFeatureRepoPath(workspaceRoot: string, featureId: string): string;
+export declare function getIssueRepoPath(workspaceRoot: string, issueId: string): string;
 /**
- * Check if a feature's repo already exists locally
+ * Check if an issue's repo already exists locally
  */
-export declare function featureRepoExists(workspaceRoot: string, featureId: string): boolean;
+export declare function issueRepoExists(workspaceRoot: string, issueId: string): boolean;
 /**
- * Clone a repository for a feature using GitHub App installation token
+ * Clone a repository for an issue using GitHub App installation token
  *
  * Uses `git -c credential.helper` to pass the token securely
  * instead of embedding it in the clone URL (which would be visible via `ps`).
  *
  * @param workspaceRoot - The workspace root directory
- * @param featureId - The feature ID (used as directory name)
+ * @param issueId - The issue ID (used as directory name)
  * @param owner - GitHub repo owner
  * @param repo - GitHub repo name
  * @param token - GitHub installation token
- * @returns FeatureRepo with the path and clone status
+ * @returns IssueRepo with the path and clone status
  */
-export declare function cloneFeatureRepo(workspaceRoot: string, featureId: string, owner: string, repo: string, token: string): FeatureRepo;
+export declare function cloneIssueRepo(workspaceRoot: string, issueId: string, owner: string, repo: string, token: string): IssueRepo;
 /**
  * Loose validator for a git ref name (tag or branch) coming from callers
  * that pass data originating from external sources (GitHub API, AI output).
@@ -61,7 +61,7 @@ export declare function cloneFeatureRepo(workspaceRoot: string, featureId: strin
  */
 export declare function isSafeGitRef(ref: string): boolean;
 /**
- * Sync a cloned feature repo to a specific git ref — a tag or a branch.
+ * Sync a cloned issue repo to a specific git ref — a tag or a branch.
  *
  * Behaviour:
  * - `git fetch origin --tags --prune` brings in new tags (release tags!) and
@@ -84,12 +84,12 @@ export declare function syncRepoToRef(repoPath: string, ref: {
     branch?: string;
 }, token: string): void;
 /**
- * Set up a feature's repo for work (install deps, etc.)
+ * Set up an issue's repo for work (install deps, etc.)
  * This is called after cloning or reusing a repo
  */
-export declare function setupFeatureRepo(repoPath: string): void;
+export declare function setupIssueRepo(repoPath: string): void;
 /**
- * Update the remote token for a feature repo
+ * Update the remote token for an issue repo
  * Used when the installation token has been refreshed
  */
 export declare function updateRepoToken(repoPath: string, owner: string, repo: string, _token: string): void;

package/dist/workspace/workspace-manager.js

@@ -1,11 +1,11 @@
 /**
- * Workspace Manager - Manages the edsger working directory and feature repos
+ * Workspace Manager - Manages the edsger working directory and issue repos
  *
  * Handles:
  * - Detecting or creating the 'edsger' working directory
  * - Cloning repos using GitHub App installation tokens
- * - Using feature ID as directory name for cloned repos
- * - Reusing existing cloned repos for the same feature
+ * - Using issue ID as directory name for cloned repos
+ * - Reusing existing cloned repos for the same issue
  */
 import { execFileSync, execSync } from 'child_process';
 import { existsSync, mkdirSync } from 'fs';
@@ -41,34 +41,34 @@ export function ensureWorkspaceDir() {
     return workspaceRoot;
 }
 /**
- * Get the directory path for a feature's repo clone
- * Uses the feature ID as the directory name
+ * Get the directory path for an issue's repo clone
+ * Uses the issue ID as the directory name
  */
-export function getFeatureRepoPath(workspaceRoot, featureId) {
-    return join(workspaceRoot, featureId);
+export function getIssueRepoPath(workspaceRoot, issueId) {
+    return join(workspaceRoot, issueId);
 }
 /**
- * Check if a feature's repo already exists locally
+ * Check if an issue's repo already exists locally
  */
-export function featureRepoExists(workspaceRoot, featureId) {
-    const repoPath = getFeatureRepoPath(workspaceRoot, featureId);
+export function issueRepoExists(workspaceRoot, issueId) {
+    const repoPath = getIssueRepoPath(workspaceRoot, issueId);
     return existsSync(join(repoPath, '.git'));
 }
 /**
- * Clone a repository for a feature using GitHub App installation token
+ * Clone a repository for an issue using GitHub App installation token
  *
  * Uses `git -c credential.helper` to pass the token securely
  * instead of embedding it in the clone URL (which would be visible via `ps`).
  *
  * @param workspaceRoot - The workspace root directory
- * @param featureId - The feature ID (used as directory name)
+ * @param issueId - The issue ID (used as directory name)
  * @param owner - GitHub repo owner
  * @param repo - GitHub repo name
  * @param token - GitHub installation token
- * @returns FeatureRepo with the path and clone status
+ * @returns IssueRepo with the path and clone status
  */
-export function cloneFeatureRepo(workspaceRoot, featureId, owner, repo, token) {
-    const repoPath = getFeatureRepoPath(workspaceRoot, featureId);
+export function cloneIssueRepo(workspaceRoot, issueId, owner, repo, token) {
+    const repoPath = getIssueRepoPath(workspaceRoot, issueId);
     const repoUrl = `https://github.com/${owner}/${repo}.git`;
     // Use the shared credential helper builder. Passes the installation
     // token via `git -c credential.helper=...` so it stays out of the
@@ -76,7 +76,7 @@ export function cloneFeatureRepo(workspaceRoot, featureId, owner, repo, token) {
     const gitCredentialArgs = buildCredentialArgs(token);
     // Check if already cloned
     if (existsSync(join(repoPath, '.git'))) {
-        logInfo(`Reusing existing repo for feature ${featureId}`);
+        logInfo(`Reusing existing repo for issue ${issueId}`);
         // Update the remote URL (without token) and fetch using credential helper
         try {
             execSync(`git remote set-url origin "${repoUrl}"`, {
@@ -102,7 +102,7 @@ export function cloneFeatureRepo(workspaceRoot, featureId, owner, repo, token) {
         return { repoPath, freshClone: false };
     }
     // Clone fresh using credential helper
-    logInfo(`Cloning ${owner}/${repo} for feature ${featureId}...`);
+    logInfo(`Cloning ${owner}/${repo} for issue ${issueId}...`);
     // Use execFileSync to avoid shell interpretation of credential helper metacharacters
     try {
         execFileSync('git', [...gitCredentialArgs, 'clone', repoUrl, repoPath], {
@@ -142,7 +142,7 @@ export function isSafeGitRef(ref) {
     return /^[A-Za-z0-9._\-+/@]+$/.test(ref);
 }
 /**
- * Sync a cloned feature repo to a specific git ref — a tag or a branch.
+ * Sync a cloned issue repo to a specific git ref — a tag or a branch.
  *
  * Behaviour:
  * - `git fetch origin --tags --prune` brings in new tags (release tags!) and
@@ -221,10 +221,10 @@ export function syncRepoToRef(repoPath, ref, token) {
     }
 }
 /**
- * Set up a feature's repo for work (install deps, etc.)
+ * Set up an issue's repo for work (install deps, etc.)
  * This is called after cloning or reusing a repo
  */
-export function setupFeatureRepo(repoPath) {
+export function setupIssueRepo(repoPath) {
     // Check for package.json and install deps if needed
     if (existsSync(join(repoPath, 'package.json'))) {
         try {
@@ -241,7 +241,7 @@ export function setupFeatureRepo(repoPath) {
     }
 }
 /**
- * Update the remote token for a feature repo
+ * Update the remote token for an issue repo
  * Used when the installation token has been refreshed
  */
 export function updateRepoToken(repoPath, owner, repo, _token) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.50.0",
+  "version": "0.52.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"

package/vitest.config.ts

@@ -9,6 +9,10 @@ export default defineConfig({
     include: [
       'src/phases/run-sheet/__tests__/**/*.test.ts',
       'src/phases/code-refine-verification/__tests__/**/*.test.ts',
+      'src/phases/find-bugs/__tests__/**/*.test.ts',
+      'src/phases/find-features/__tests__/**/*.test.ts',
+      'src/phases/find-smells/__tests__/**/*.test.ts',
+      'src/commands/find-smells/__tests__/**/*.test.ts',
     ],
     exclude: ['dist/**', 'node_modules/**'],
     environment: 'node',

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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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);
-    });
-});