edsger 0.50.0 → 0.52.0

package/dist/phases/find-smells/prompts.js

@@ -0,0 +1,129 @@
+/**
+ * Prompts for the find-smells phase. The agent runs with cwd=repo checkout
+ * and has Read/Grep/Glob/Bash available — it explores the code itself
+ * rather than receiving a pre-baked diff.
+ *
+ * Boundary against neighbouring phases:
+ *   - find-bugs handles real defects (security, correctness, races, etc.)
+ *   - find-features handles missing user-facing capability
+ *   - find-smells (this phase) handles "the code would be better if changed":
+ *     refactor candidates, dead code, perf cliffs, type-safety gaps, etc.
+ */
+export function createFindSmellsSystemPrompt() {
+    return `You are a senior engineer auditing a codebase for **code smells** — concrete improvements the codebase would benefit from. You have read-only access via Read/Grep/Glob and may run shallow Bash queries (e.g. \`git log\`, \`wc -l\`) to navigate.
+
+**What counts as a smell worth filing**:
+1. **Refactor**: duplicated logic across files, tangled module boundaries, leaky abstractions, primitive obsession
+2. **Performance**: clearly-suboptimal patterns (N+1 queries, unbounded loops on growing data, repeated work that could be cached, sync I/O in hot paths) that are not yet causing user-visible bugs
+3. **Duplication**: copy-pasted blocks that should be a single helper
+4. **Complexity**: functions / files that are too long or too deeply nested to reason about, cyclomatic-complexity hotspots
+5. **Dead code**: unreferenced exports, unreachable branches, abandoned feature flags, commented-out blocks
+6. **Type safety**: \`any\` / \`unknown\` casts, \`@ts-ignore\` / \`@ts-expect-error\`, missing null checks at trust boundaries, loose interfaces that should be tightened
+7. **Readability**: misleading names, missing or wrong comments, magic numbers that should be named constants
+8. **Architecture**: cyclic deps, layering violations, modules that have grown into multiple responsibilities
+
+**What does NOT count** (skip these — wrong tool):
+- Real bugs (security holes, logic errors, races, data corruption) — those belong in \`edsger find-bugs\`. **Don't drop them silently — list them in \`deferred_to_bugs\` so the user knows to run that command.**
+- Missing user-facing features or workflows — those belong in \`edsger find-features\`. **List them in \`deferred_to_features\` instead of dropping them.**
+- Pure style / formatting / lint issues a formatter would catch
+- "Could be more idiomatic" rewrites with no concrete benefit
+- Hypothetical future-scaling concerns with no current evidence
+- Missing tests (track those separately, not here)
+
+**Discipline**:
+- Be concrete: cite the exact file and line. Quote the offending snippet in the description, and propose the specific change.
+- Be conservative: if you can't articulate the *benefit* of changing it (clarity, perf number, removed coupling), skip it.
+- Severity rubric:
+  - high = pays back quickly (e.g. removes a hot-path N+1, deletes a large dead module, unblocks future work the team is clearly trying to do)
+  - medium = clear improvement but not urgent (typical refactor candidate)
+  - low = nice-to-have polish; only file if the change is small and obvious
+- **Deduplication**: you will be given the list of existing open issues. Skip any finding that overlaps. Better to under-report than spam duplicates.
+
+**CRITICAL — Output Format**:
+End your response with a single JSON code block in this exact shape:
+
+\`\`\`json
+{
+  "scan_result": {
+    "summary": "Reviewed N files in <scope>; found X smells (Y high, Z medium).",
+    "scanned_commit_sha": "<the HEAD sha you scanned>",
+    "smells": [
+      {
+        "title": "Short, action-oriented title (under 80 chars)",
+        "description": "## What\\nWhat the smell is, with the offending snippet quoted.\\n\\n## Why it matters\\nConcrete benefit of changing it (clarity, perf, decoupling).\\n\\n## Suggested change\\nA specific refactor or replacement.",
+        "file": "relative/path/from/repo/root.ts",
+        "line": 42,
+        "severity": "medium",
+        "category": "refactor",
+        "dedup_signature": "auth-service-duplicated-token-parser"
+      }
+    ],
+    "deferred_to_bugs": [
+      {
+        "title": "Short title of the suspected bug",
+        "reason": "One-line note of why this looks like a real defect, not a smell",
+        "file": "relative/path.ts",
+        "line": 100
+      }
+    ],
+    "deferred_to_features": [
+      {
+        "title": "Short title of the missing capability",
+        "reason": "One-line note of the user need this would address",
+        "file": "relative/path.ts"
+      }
+    ]
+  }
+}
+\`\`\`
+
+If you find nothing worth filing, still emit the JSON with an empty \`smells\` array. The \`deferred_to_*\` arrays are optional — omit them or send \`[]\` if there's nothing to hand off.`;
+}
+export function createFindSmellsUserPrompt(params) {
+    const { productName, productDescription, scope, baseSha, headSha, changedPaths, existingIssues, maxFiles, categories, } = params;
+    const productBlock = productDescription
+        ? `**Product**: ${productName}\n${productDescription}`
+        : `**Product**: ${productName}`;
+    const scopeBlock = scope === 'incremental' && baseSha
+        ? `**Scope**: incremental scan of changes between ${baseSha} and ${headSha}.\nUse \`git diff --name-only ${baseSha}..${headSha}\` to enumerate changed files, then Read/Grep them. Do NOT scan files outside the diff.`
+        : `**Scope**: full repository scan at ${headSha}. Use Glob to enumerate source files. Skip vendored code, build output, generated files, lockfiles, and \`node_modules\`.`;
+    const filesHint = changedPaths && changedPaths.length > 0
+        ? `\n**Changed files in this range** (${changedPaths.length}):\n${changedPaths
+            .slice(0, 200)
+            .map((p) => `- ${p}`)
+            .join('\n')}${changedPaths.length > 200 ? `\n…and ${changedPaths.length - 200} more.` : ''}`
+        : '';
+    const issuesBlock = existingIssues.length === 0
+        ? 'No existing open issues for this product — every finding is new.'
+        : `**Existing open issues** (${existingIssues.length}) — skip findings that overlap with any of these:\n${existingIssues
+            .map((i) => `- [${i.id}] ${i.name}${i.description ? `\n  ${truncate(i.description, 200)}` : ''}`)
+            .join('\n')}`;
+    const budgetBlock = typeof maxFiles === 'number' && maxFiles > 0
+        ? `\n**Budget**: Read at most ${maxFiles} files. Prioritise files most likely to harbour smells (large modules, frequently-edited code per \`git log\`, files with \`any\`/\`@ts-ignore\`, hot data-access paths) over test fixtures and generated code. If the scope is larger than the budget, stop when you hit it and report truncation in \`summary\`.`
+        : '';
+    const categoryBlock = categories && categories.length > 0
+        ? `\n**Category filter**: only file findings whose \`category\` is one of: ${categories.join(', ')}. Drop everything else.`
+        : '';
+    return `${productBlock}
+
+${scopeBlock}${filesHint}${budgetBlock}${categoryBlock}
+
+${issuesBlock}
+
+## How to work
+
+1. Identify the files in scope (per the scope block above).
+2. For each file, Read it and look for the smell categories listed in the system prompt.
+3. When you suspect a smell, re-read the surrounding context to confirm the *benefit* of changing it. If you can't name the benefit, drop it.
+4. If something looks like a real bug (not a smell), drop it — \`edsger find-bugs\` covers that.
+5. Cross-check every candidate against the existing issues list. Drop overlaps.
+6. Produce the final JSON described in the system prompt.
+
+Begin.`;
+}
+function truncate(s, n) {
+    if (s.length <= n) {
+        return s;
+    }
+    return `${s.slice(0, n)}…`;
+}

package/dist/phases/find-smells/state.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Per-product scan state for find-smells. Storage at
+ * `~/.edsger/find-smells-state/<productId>.json`.
+ *
+ * Same schema shape as find-bugs (incremental sha tracking) — file/lock
+ * machinery shared via createScanStateModule. Kept as a sibling state file
+ * (not merged with find-bugs) so a smell scan and a bug scan can run
+ * concurrently without contending on the same lock.
+ */
+import { type LockHandle } from '../find-shared/scan-state.js';
+export type { LockHandle };
+export interface FindSmellsState {
+    lastScannedCommitSha?: string;
+    lastScannedAt?: string;
+    lastAttemptedAt?: string;
+    lastError?: string;
+}
+export declare const loadFindSmellsState: (productId: string) => FindSmellsState;
+export declare const saveFindSmellsState: (productId: string, state: FindSmellsState) => void;
+export declare const updateFindSmellsState: (productId: string, patch: Partial<FindSmellsState>) => FindSmellsState;
+export declare const acquireFindSmellsLock: (productId: string, staleAfterMs?: number) => LockHandle | null;

package/dist/phases/find-smells/state.js

@@ -0,0 +1,17 @@
+/**
+ * Per-product scan state for find-smells. Storage at
+ * `~/.edsger/find-smells-state/<productId>.json`.
+ *
+ * Same schema shape as find-bugs (incremental sha tracking) — file/lock
+ * machinery shared via createScanStateModule. Kept as a sibling state file
+ * (not merged with find-bugs) so a smell scan and a bug scan can run
+ * concurrently without contending on the same lock.
+ */
+import { createScanStateModule, } from '../find-shared/scan-state.js';
+const m = createScanStateModule({
+    dirName: 'find-smells-state',
+});
+export const loadFindSmellsState = m.load;
+export const saveFindSmellsState = m.save;
+export const updateFindSmellsState = m.update;
+export const acquireFindSmellsLock = m.acquireLock;

package/dist/phases/find-smells/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Types for the find-smells phase.
+ *
+ * A "smell" here is anything the codebase would benefit from changing but that
+ * is **not** a real bug (find-bugs handles those) and **not** a missing feature
+ * (find-features handles those). Refactor candidates, dead code, performance
+ * cliffs, type-safety gaps, and over-complex modules all live here.
+ */
+export type SmellSeverity = 'high' | 'medium' | 'low';
+/**
+ * Authoritative list of allowed categories. Kept as a `const` array so the
+ * type and the runtime whitelist can never drift apart — `SmellCategory` is
+ * derived from it, and `isSmellCategory` checks against it.
+ */
+export declare const SMELL_CATEGORIES: readonly ["refactor", "performance", "duplication", "complexity", "dead_code", "type_safety", "readability", "architecture", "other"];
+export type SmellCategory = (typeof SMELL_CATEGORIES)[number];
+export declare function isSmellCategory(value: unknown): value is SmellCategory;
+export interface SmellFinding {
+    title: string;
+    description: string;
+    file: string;
+    line?: number;
+    severity: SmellSeverity;
+    category: SmellCategory;
+    /** Stable signature for log/audit; not used for storage dedup. */
+    dedup_signature?: string;
+}
+/**
+ * A finding the agent saw but is handing off to a sibling phase rather than
+ * filing as a smell. Surfaced in the run log so the user knows the work
+ * wasn't silently lost — they can run `edsger find-bugs` / `find-features`
+ * to pick it up.
+ */
+export interface DeferredFinding {
+    title: string;
+    /** One-line reason the agent thinks the sibling phase owns this. */
+    reason: string;
+    file?: string;
+    line?: number;
+}
+export declare function isDeferredFinding(value: unknown): value is DeferredFinding;
+export interface ScanResult {
+    summary: string;
+    scanned_commit_sha?: string;
+    smells: SmellFinding[];
+    /** Findings the agent thinks belong in `edsger find-bugs`. */
+    deferred_to_bugs?: DeferredFinding[];
+    /** Findings the agent thinks belong in `edsger find-features`. */
+    deferred_to_features?: DeferredFinding[];
+}
+export declare function isScanResult(value: unknown): value is ScanResult;

package/dist/phases/find-smells/types.js

@@ -0,0 +1,64 @@
+/**
+ * Types for the find-smells phase.
+ *
+ * A "smell" here is anything the codebase would benefit from changing but that
+ * is **not** a real bug (find-bugs handles those) and **not** a missing feature
+ * (find-features handles those). Refactor candidates, dead code, performance
+ * cliffs, type-safety gaps, and over-complex modules all live here.
+ */
+/**
+ * Authoritative list of allowed categories. Kept as a `const` array so the
+ * type and the runtime whitelist can never drift apart — `SmellCategory` is
+ * derived from it, and `isSmellCategory` checks against it.
+ */
+export const SMELL_CATEGORIES = [
+    'refactor',
+    'performance',
+    'duplication',
+    'complexity',
+    'dead_code',
+    'type_safety',
+    'readability',
+    'architecture',
+    'other',
+];
+export function isSmellCategory(value) {
+    return (typeof value === 'string' &&
+        SMELL_CATEGORIES.includes(value));
+}
+export function isDeferredFinding(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    return typeof v.title === 'string' && typeof v.reason === 'string';
+}
+export function isScanResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    if (typeof v.summary !== 'string' || !Array.isArray(v.smells)) {
+        return false;
+    }
+    const smellsOk = v.smells.every((s) => s &&
+        typeof s === 'object' &&
+        typeof s.title === 'string' &&
+        typeof s.description === 'string' &&
+        typeof s.file === 'string');
+    if (!smellsOk) {
+        return false;
+    }
+    // Deferred arrays are optional but, if present, must be well-formed —
+    // otherwise we'd silently drop hand-offs the agent intended us to log.
+    for (const key of ['deferred_to_bugs', 'deferred_to_features']) {
+        const arr = v[key];
+        if (arr === undefined) {
+            continue;
+        }
+        if (!Array.isArray(arr) || !arr.every(isDeferredFinding)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/phases/functional-testing/analyzer.d.ts

@@ -2,7 +2,7 @@ import { type ChecklistPhaseContext } from '../../services/checklist.js';
 import { type EdsgerConfig } from '../../types/index.js';
 import { type TestReportResult } from './test-report-creator.js';
 export interface FunctionalTestingOptions {
-    featureId: string;
+    issueId: string;
     verbose?: boolean;
 }
 export interface StructuredTestResult {
@@ -28,7 +28,7 @@ export interface StructuredTestResult {
     }[];
 }
 export interface FunctionalTestingResult {
-    featureId: string;
+    issueId: string;
     testStatus: 'testing_passed' | 'testing_failed';
     structuredTestResult: StructuredTestResult | null;
     testReport?: TestReportResult;

package/dist/phases/functional-testing/analyzer.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines -- orchestration module with test execution, result processing, and report generation */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { updateFeatureStatus } from '../../api/features/index.js';
+import { updateIssueStatus } from '../../api/issues/index.js';
 import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -170,11 +170,11 @@ function parseTestResult(responseText) {
 /**
  * Resolve the branch to use for testing
  */
-async function resolveTestBranch(featureId, verbose) {
-    let branchName = `dev/${featureId}`;
+async function resolveTestBranch(issueId, verbose) {
+    let branchName = `dev/${issueId}`;
     let currentBranch = null;
     try {
-        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        currentBranch = await getReadyForReviewBranch({ issueId, verbose });
         if (currentBranch?.branch_name) {
             branchName = currentBranch.branch_name;
             if (verbose) {
@@ -188,7 +188,7 @@ async function resolveTestBranch(featureId, verbose) {
     }
     catch (_error) {
         if (verbose) {
-            logInfo(`Note: Could not fetch feature branches, using default branch`);
+            logInfo(`Note: Could not fetch issue branches, using default branch`);
         }
     }
     return { branchName, currentBranch };
@@ -196,9 +196,9 @@ async function resolveTestBranch(featureId, verbose) {
 /**
  * Fetch feedbacks for testing context
  */
-async function fetchTestingFeedbacks(featureId, currentBranch, verbose) {
+async function fetchTestingFeedbacks(issueId, currentBranch, verbose) {
     try {
-        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'functional_testing', currentBranch?.id);
+        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'functional_testing', currentBranch?.id);
         if (feedbacksContext.feedbacks.length > 0) {
             const info = await formatFeedbacksForContext(feedbacksContext);
             if (verbose) {
@@ -217,7 +217,7 @@ async function fetchTestingFeedbacks(featureId, currentBranch, verbose) {
 /**
  * Map test results to existing test cases by name matching
  */
-async function mapTestResultsToTestCases(structuredTestResult, featureId, verbose) {
+async function mapTestResultsToTestCases(structuredTestResult, issueId, verbose) {
     if (!structuredTestResult.test_cases?.length) {
         return undefined;
     }
@@ -233,7 +233,7 @@ async function mapTestResultsToTestCases(structuredTestResult, featureId, verbos
             body: JSON.stringify({
                 jsonrpc: '2.0',
                 method: 'test_cases/list',
-                params: { feature_id: featureId },
+                params: { issue_id: issueId },
                 id: Math.random().toString(36).substring(7),
             }),
         });
@@ -275,12 +275,12 @@ async function mapTestResultsToTestCases(structuredTestResult, featureId, verbos
 /**
  * Save test status and create test report
  */
-async function saveTestResults(featureId, testStatus, structuredTestResult, lastAssistantResponse, verbose) {
+async function saveTestResults(issueId, testStatus, structuredTestResult, lastAssistantResponse, verbose) {
     if (verbose) {
         logInfo('Saving test results...');
     }
-    const statusSaved = await updateFeatureStatus({
-        featureId,
+    const statusSaved = await updateIssueStatus({
+        issueId,
         status: testStatus,
         verbose,
     });
@@ -289,7 +289,7 @@ async function saveTestResults(featureId, testStatus, structuredTestResult, last
             logInfo('Direct status update failed, trying HTTP fallback...');
         }
         const fallbackSaved = await saveFunctionalTestResultsWithRetry({
-            featureId,
+            issueId,
             testStatus,
             testResults: structuredTestResult?.execution_details || lastAssistantResponse,
             verbose,
@@ -311,9 +311,9 @@ async function saveTestResults(featureId, testStatus, structuredTestResult, last
         testResults: structuredTestResult.execution_details || lastAssistantResponse,
         status: testStatus,
     };
-    const testResults = await mapTestResultsToTestCases(structuredTestResult, featureId, verbose);
+    const testResults = await mapTestResultsToTestCases(structuredTestResult, issueId, verbose);
     const testReportResult = await createTestReport({
-        featureId,
+        issueId,
         testReportData,
         testResults,
         verbose,
@@ -328,22 +328,22 @@ async function saveTestResults(featureId, testStatus, structuredTestResult, last
 }
 // eslint-disable-next-line complexity
 export const runFunctionalTesting = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
+    const { issueId, verbose } = options;
     if (verbose) {
-        logInfo(`Starting functional testing for feature ID: ${featureId}`);
+        logInfo(`Starting functional testing for issue ID: ${issueId}`);
     }
-    const { branchName, currentBranch } = await resolveTestBranch(featureId, verbose);
+    const { branchName, currentBranch } = await resolveTestBranch(issueId, verbose);
     const cleanupGit = currentBranch
         ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
-        : preparePhaseGitEnvironment(featureId, 'main', verbose);
+        : preparePhaseGitEnvironment(issueId, 'main', verbose);
     try {
         if (verbose) {
-            logInfo('Fetching feature testing context via MCP endpoints...');
+            logInfo('Fetching issue testing context via MCP endpoints...');
         }
-        const context = await fetchFunctionalTestingContext(featureId, verbose);
-        const feedbacksInfo = await fetchTestingFeedbacks(featureId, currentBranch, verbose);
-        const systemPrompt = createSystemPrompt(config, featureId);
-        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose, feedbacksInfo);
+        const context = await fetchFunctionalTestingContext(issueId, verbose);
+        const feedbacksInfo = await fetchTestingFeedbacks(issueId, currentBranch, verbose);
+        const systemPrompt = createSystemPrompt(config, issueId);
+        const testingPrompt = createTestingPromptWithContext(issueId, context, checklistContext, verbose, feedbacksInfo);
         let lastAssistantResponse = '';
         let structuredTestResult = null;
         let testStatus = 'testing_failed';
@@ -402,10 +402,10 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
                 }
             }
         }
-        const testReportResult = await saveTestResults(featureId, testStatus, structuredTestResult, lastAssistantResponse, verbose);
+        const testReportResult = await saveTestResults(issueId, testStatus, structuredTestResult, lastAssistantResponse, verbose);
         if (structuredTestResult) {
             return {
-                featureId,
+                issueId,
                 testStatus,
                 structuredTestResult,
                 testReport: testReportResult,
@@ -417,7 +417,7 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
             };
         }
         return {
-            featureId,
+            issueId,
             testStatus: 'testing_failed',
             structuredTestResult: null,
             testReport: testReportResult,
@@ -428,14 +428,14 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
     catch (error) {
         logError(`Functional testing failed: ${error instanceof Error ? error.message : String(error)}`);
         try {
-            const errorSaved = await updateFeatureStatus({
-                featureId,
+            const errorSaved = await updateIssueStatus({
+                issueId,
                 status: 'testing_failed',
                 verbose,
             });
             if (!errorSaved) {
                 await saveFunctionalTestResultsWithRetry({
-                    featureId,
+                    issueId,
                     testStatus: 'testing_failed',
                     testResults: `Testing failed: ${error instanceof Error ? error.message : String(error)}`,
                     verbose,
@@ -448,7 +448,7 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
             }
         }
         return {
-            featureId,
+            issueId,
             testStatus: 'testing_failed',
             structuredTestResult: null,
             status: 'error',
@@ -459,9 +459,9 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
         cleanupGit();
     }
 };
-const createSystemPrompt = (_config, mcpServerUrl, mcpToken, featureId) => {
+const createSystemPrompt = (_config, mcpServerUrl, mcpToken, issueId) => {
     let mcpInstructions = '';
-    if (mcpServerUrl && mcpToken && featureId) {
+    if (mcpServerUrl && mcpToken && issueId) {
         mcpInstructions = `
 
 **MANDATORY Checklist Compliance**:
@@ -478,7 +478,7 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
     }
     return `You are a professional QA automation engineer performing comprehensive functional testing using headless Playwright MCP.
 
-**Your Role**: Execute end-to-end functional tests for implemented features using headless browser automation.
+**Your Role**: Execute end-to-end functional tests for implemented issues using headless browser automation.
 
 **Available Tools**:
 - Headless Playwright MCP: Full headless browser automation capabilities for testing
@@ -508,8 +508,8 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
 - Optimize for performance in headless environments
 
 **Important Notes**:
-- The feature has already been implemented - you're testing existing functionality
-- All feature information, user stories, test cases, and credentials are provided in the prompt
+- The issue has already been implemented - you're testing existing functionality
+- All issue information, user stories, test cases, and credentials are provided in the prompt
 - You need to start the development server yourself (npm run dev, etc.)
 - Use the provided login credentials for authentication
 - ALWAYS configure browser in HEADLESS mode for better performance and CI/CD compatibility
@@ -558,7 +558,7 @@ IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the
 
 Focus on systematic testing based on the provided context information.${mcpInstructions}`;
 };
-const createTestingPromptWithContext = (featureId, context, checklistContext, verbose, feedbacksInfo) => {
+const createTestingPromptWithContext = (issueId, context, checklistContext, verbose, feedbacksInfo) => {
     const contextInfo = formatContextForPrompt(context);
     let finalContextInfo = contextInfo;
     // Add feedbacks context to the testing prompt
@@ -573,7 +573,7 @@ const createTestingPromptWithContext = (featureId, context, checklistContext, ve
             logInfo(`Added ${checklistContext.checklists.length} checklists to testing context`);
         }
     }
-    return `Please perform comprehensive functional testing for feature ID: ${featureId}
+    return `Please perform comprehensive functional testing for issue ID: ${issueId}
 
 ${finalContextInfo}
 
@@ -590,7 +590,7 @@ Follow this systematic approach:
    - Log in using the provided credentials from the environment configuration
    - Test each user story requirement systematically
    - Execute all test cases, especially the CRITICAL ones
-   - Verify the feature works according to the technical design
+   - Verify the issue works according to the technical design
    - Test error handling and edge cases
 
 3. **Report Results**: Provide detailed test results including:
@@ -604,7 +604,7 @@ Follow this systematic approach:
 - Focus on the critical test cases marked as [CRITICAL]
 - Ensure all user stories are properly validated
 - Test both positive and negative scenarios
-- The feature should already be implemented - you're validating existing functionality
+- The issue should already be implemented - you're validating existing functionality
 - Use the login credentials provided in the environment configuration
 - Be thorough but efficient in your testing approach
 

package/dist/phases/functional-testing/context-fetcher.d.ts

@@ -1,7 +1,7 @@
 import { type ProductInfo } from '../../api/products.js';
-import type { FeatureInfo, TestCase, UserStory } from '../../types/features.js';
+import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
 export interface FunctionalTestingContext {
-    feature: FeatureInfo;
+    issue: IssueInfo;
     product: ProductInfo;
     user_stories: UserStory[];
     test_cases: TestCase[];
@@ -9,7 +9,7 @@ export interface FunctionalTestingContext {
 /**
  * Fetch all functional testing context information via MCP endpoints
  */
-export declare function fetchFunctionalTestingContext(featureId: string, verbose?: boolean): Promise<FunctionalTestingContext>;
+export declare function fetchFunctionalTestingContext(issueId: string, verbose?: boolean): Promise<FunctionalTestingContext>;
 /**
  * Format the context into a readable string for Claude Code
  */

package/dist/phases/functional-testing/context-fetcher.js

@@ -1,30 +1,30 @@
-import { getFeature, getTestCases, getUserStories, } from '../../api/features/index.js';
+import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
 import { getProduct } from '../../api/products.js';
 import { logError, logInfo } from '../../utils/logger.js';
 /**
  * Fetch all functional testing context information via MCP endpoints
  */
-export async function fetchFunctionalTestingContext(featureId, verbose) {
+export async function fetchFunctionalTestingContext(issueId, verbose) {
     try {
         if (verbose) {
-            logInfo(`Fetching complete functional testing context for feature: ${featureId}`);
+            logInfo(`Fetching complete functional testing context for issue: ${issueId}`);
         }
         // Fetch all required data in parallel for better performance
-        const [feature, userStories, testCases] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
+        const [issue, userStories, testCases] = await Promise.all([
+            getIssue(issueId, verbose),
+            getUserStories(issueId, verbose),
+            getTestCases(issueId, verbose),
         ]);
-        const product = await getProduct(feature.product_id, verbose);
+        const product = await getProduct(issue.product_id, verbose);
         if (verbose) {
             logInfo(`✅ Functional testing context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Issue: ${issue.name}`);
             logInfo(`   Product: ${product.name}`);
             logInfo(`   User Stories: ${userStories.length}`);
             logInfo(`   Test Cases: ${testCases.length}`);
         }
         return {
-            feature,
+            issue,
             product,
             user_stories: userStories,
             test_cases: testCases,
@@ -60,11 +60,11 @@ export function formatContextForPrompt(context) {
     };
     return `# Functional Testing Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
-- **Current Status**: ${context.feature.status}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
+- **Description**: ${context.issue.description || 'No description provided'}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -79,5 +79,5 @@ ${formatTestCases(context.test_cases)}
 
 ---
 
-**Testing Instructions**: The feature has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
+**Testing Instructions**: The issue has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
 }

package/dist/phases/functional-testing/http-fallback.d.ts

@@ -1,10 +1,10 @@
 interface SaveFunctionalTestResultsOptions {
-    featureId: string;
+    issueId: string;
     testStatus: 'testing_in_progress' | 'testing_passed' | 'testing_failed';
     testResults?: string;
     verbose?: boolean;
 }
 export declare function saveFunctionalTestResultsViaHttp(options: SaveFunctionalTestResultsOptions): Promise<boolean>;
-export declare function verifyTestStatusSaved(featureId: string, verbose?: boolean, expectedStatus?: string): Promise<boolean>;
+export declare function verifyTestStatusSaved(issueId: string, verbose?: boolean, expectedStatus?: string): Promise<boolean>;
 export declare function saveFunctionalTestResultsWithRetry(options: SaveFunctionalTestResultsOptions, maxRetries?: number): Promise<boolean>;
 export {};