edsger 0.50.0 → 0.52.0

package/dist/commands/agent-workflow/processor.js

@@ -1,22 +1,22 @@
 /**
- * Agent Workflow Processor - Cross-product feature processing
+ * Agent Workflow Processor - Cross-product issue processing
  *
- * Uses child_process.fork() to run each feature in an isolated worker process.
+ * Uses child_process.fork() to run each issue in an isolated worker process.
  * This enables:
- * - Concurrent processing of multiple features (each worker has its own cwd)
- * - Auto-update takes effect on next feature (new workers load latest code)
+ * - Concurrent processing of multiple issues (each worker has its own cwd)
+ * - Auto-update takes effect on next issue (new workers load latest code)
  * - Crash isolation (one worker failing doesn't affect others)
  */
 import { fork } from 'child_process';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { listAllReadyFeatures, } from '../../api/cross-product.js';
+import { listAllReadyIssues, } from '../../api/cross-product.js';
 import { getGitHubConfig } from '../../api/github.js';
 import { WorkerTimeoutError } from '../../errors/index.js';
 import { sendHeartbeat, shouldProcess } from '../../system/session-manager.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneFeatureRepo } from '../../workspace/workspace-manager.js';
-import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateFeatureState, } from '../workflow/core/state-manager.js';
+import { cloneIssueRepo } from '../../workspace/workspace-manager.js';
+import { calculateStats, createCompletedState, createFailedState, createInitialState, createProcessingState, updateIssueState, } from '../workflow/core/state-manager.js';
 /**
  * Maximum allowed concurrency (hard cap).
  * Limits are due to:
@@ -31,15 +31,15 @@ export const MAX_CONCURRENCY = 10;
 const __filename = fileURLToPath(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
 const __dirname = dirname(__filename);
-const WORKER_SCRIPT = join(__dirname, 'feature-worker.js');
+const WORKER_SCRIPT = join(__dirname, 'issue-worker.js');
 const CHAT_WORKER_SCRIPT = join(__dirname, 'chat-worker.js');
 export class AgentWorkflowProcessor {
     options;
     config;
     isRunning = false;
-    processedFeatures = createInitialState();
+    processedIssues = createInitialState();
     pollTimer;
-    /** Currently active worker processes, keyed by featureId */
+    /** Currently active worker processes, keyed by issueId */
     activeWorkers = new Map();
     /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
     chatWorker;
@@ -60,14 +60,14 @@ export class AgentWorkflowProcessor {
             return;
         }
         this.isRunning = true;
-        logInfo(`Concurrent processing: up to ${this.options.maxConcurrent} feature(s)`);
+        logInfo(`Concurrent processing: up to ${this.options.maxConcurrent} issue(s)`);
         // Start chat worker subprocess
         this.startChatWorker();
-        // Initial feature check
-        await this.processNextFeatures();
+        // Initial issue check
+        await this.processNextIssues();
         // Set up polling
         this.pollTimer = setInterval(() => {
-            this.processNextFeatures().catch((error) => {
+            this.processNextIssues().catch((error) => {
                 logError(`Polling error: ${error instanceof Error ? error.message : String(error)}`);
             });
         }, this.options.pollInterval);
@@ -163,9 +163,9 @@ export class AgentWorkflowProcessor {
             }
             this.chatWorker = undefined;
         }
-        // Kill all active feature workers gracefully
-        for (const [featureId, worker] of this.activeWorkers) {
-            logInfo(`Stopping worker for feature: ${featureId}`);
+        // Kill all active issue workers gracefully
+        for (const [issueId, worker] of this.activeWorkers) {
+            logInfo(`Stopping worker for issue: ${issueId}`);
             if (worker.timeoutTimer) {
                 clearTimeout(worker.timeoutTimer);
             }
@@ -177,7 +177,7 @@ export class AgentWorkflowProcessor {
             }
         }
     }
-    async processNextFeatures() {
+    async processNextIssues() {
         try {
             // Check if we should be processing (not paused/stopped from web dashboard)
             if (!shouldProcess()) {
@@ -186,7 +186,7 @@ export class AgentWorkflowProcessor {
                 }
                 return;
             }
-            // Calculate how many more features we can take on
+            // Calculate how many more issues we can take on
             const availableSlots = this.options.maxConcurrent - this.activeWorkers.size;
             if (availableSlots <= 0) {
                 if (this.options.verbose) {
@@ -194,23 +194,23 @@ export class AgentWorkflowProcessor {
                 }
                 return;
             }
-            // Fetch ready features across all products
-            const features = await listAllReadyFeatures(this.options.verbose);
-            if (features.length === 0) {
+            // Fetch ready issues across all products
+            const issues = await listAllReadyIssues(this.options.verbose);
+            if (issues.length === 0) {
                 if (this.options.verbose) {
-                    logInfo('No features available for processing');
+                    logInfo('No issues available for processing');
                 }
                 return;
             }
-            // Filter out features already being processed or recently failed
+            // Filter out issues already being processed or recently failed
             const cooldownMs = this.config.workflow.retryCooldown;
-            const newFeatures = features.filter((f) => {
+            const newIssues = issues.filter((f) => {
                 if (this.activeWorkers.has(f.id)) {
                     return false;
                 }
-                const state = this.processedFeatures.get(f.id);
+                const state = this.processedIssues.get(f.id);
                 if (state?.status === 'failed') {
-                    // Allow retry if feature was updated after our last attempt (user intervention)
+                    // Allow retry if issue was updated after our last attempt (user intervention)
                     if (f.updated_at && new Date(f.updated_at) > state.lastAttempt) {
                         return true;
                     }
@@ -225,88 +225,88 @@ export class AgentWorkflowProcessor {
                 }
                 return true;
             });
-            if (newFeatures.length === 0) {
-                // Log skipped features for debugging
-                const skippedCount = features.filter((f) => {
-                    const state = this.processedFeatures.get(f.id);
+            if (newIssues.length === 0) {
+                // Log skipped issues for debugging
+                const skippedCount = issues.filter((f) => {
+                    const state = this.processedIssues.get(f.id);
                     return (state?.status === 'failed' &&
                         state.retryCount >= this.options.maxRetries);
                 }).length;
                 if (skippedCount > 0) {
-                    logInfo(`${skippedCount} feature(s) skipped (max retries exceeded)`);
+                    logInfo(`${skippedCount} issue(s) skipped (max retries exceeded)`);
                 }
                 if (this.options.verbose) {
-                    logInfo('No features available for processing');
+                    logInfo('No issues available for processing');
                 }
                 return;
             }
-            // Pick features up to available slots
-            const toProcess = newFeatures.slice(0, availableSlots);
-            // Start processing each feature concurrently
-            for (const feature of toProcess) {
-                this.startFeatureWorker(feature).catch((error) => {
-                    logError(`Failed to start worker for ${feature.name}: ${error instanceof Error ? error.message : String(error)}`);
+            // Pick issues up to available slots
+            const toProcess = newIssues.slice(0, availableSlots);
+            // Start processing each issue concurrently
+            for (const issue of toProcess) {
+                this.startIssueWorker(issue).catch((error) => {
+                    logError(`Failed to start worker for ${issue.name}: ${error instanceof Error ? error.message : String(error)}`);
                 });
             }
         }
         catch (error) {
-            logError(`Failed to process features: ${error instanceof Error ? error.message : String(error)}`);
+            logError(`Failed to process issues: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * Start a child process worker for a single feature.
+     * Start a child process worker for a single issue.
      * Handles: GitHub config lookup, repo cloning, then forks the worker.
      */
-    async startFeatureWorker(feature) {
-        const featureId = feature.id;
+    async startIssueWorker(issue) {
+        const issueId = issue.id;
         // Update state to processing
-        this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createProcessingState(featureId, currentState));
-        logInfo(`Processing feature: ${feature.name}`);
-        if (feature.product_name) {
-            logInfo(`  Product: ${feature.product_name}`);
+        this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createProcessingState(issueId, currentState));
+        logInfo(`Processing issue: ${issue.name}`);
+        if (issue.product_name) {
+            logInfo(`  Product: ${issue.product_name}`);
         }
-        // Send heartbeat with current feature info
-        await sendHeartbeat(featureId, feature.name);
+        // Send heartbeat with current issue info
+        await sendHeartbeat(issueId, issue.name);
         try {
-            // Step 1: Get GitHub config for this feature
-            const githubConfig = await getGitHubConfig(featureId, this.options.verbose);
+            // Step 1: Get GitHub config for this issue
+            const githubConfig = await getGitHubConfig(issueId, this.options.verbose);
             if (!githubConfig.configured ||
                 !githubConfig.token ||
                 !githubConfig.owner ||
                 !githubConfig.repo) {
-                logWarning(`GitHub not configured for feature: ${feature.name}. ${githubConfig.message || ''}`);
-                this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
+                logWarning(`GitHub not configured for issue: ${issue.name}. ${githubConfig.message || ''}`);
+                this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
                 return;
             }
             // Step 2: Clone or reuse repo
-            const { repoPath, freshClone } = cloneFeatureRepo(this.options.workspaceRoot, featureId, githubConfig.owner, githubConfig.repo, githubConfig.token);
+            const { repoPath, freshClone } = cloneIssueRepo(this.options.workspaceRoot, issueId, githubConfig.owner, githubConfig.repo, githubConfig.token);
             logInfo(`Repo: ${repoPath} (${freshClone ? 'fresh clone' : 'reused'})`);
-            // Step 3: Fork a worker process to run the feature workflow
-            // The worker runs with cwd set to the repo path, so each feature
+            // Step 3: Fork a worker process to run the issue workflow
+            // The worker runs with cwd set to the repo path, so each issue
             // has its own isolated working directory.
             const worker = fork(WORKER_SCRIPT, [], {
                 cwd: repoPath,
                 stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
                 env: {
                     ...process.env,
-                    EDSGER_FEATURE_ID: featureId,
+                    EDSGER_ISSUE_ID: issueId,
                 },
             });
             // Track the active worker
             const activeWorker = {
                 process: worker,
-                featureId,
-                featureName: feature.name,
+                issueId,
+                issueName: issue.name,
                 startedAt: new Date(),
             };
-            this.activeWorkers.set(featureId, activeWorker);
-            logInfo(`Worker spawned for feature: ${feature.name} (pid: ${worker.pid})`);
+            this.activeWorkers.set(issueId, activeWorker);
+            logInfo(`Worker spawned for issue: ${issue.name} (pid: ${worker.pid})`);
             // Forward worker stdout/stderr to parent logs
             worker.stdout?.on('data', (data) => {
                 const lines = data.toString().trim().split('\n');
                 for (const line of lines) {
                     if (line) {
-                        logInfo(`  [${feature.name}] ${line}`);
+                        logInfo(`  [${issue.name}] ${line}`);
                     }
                 }
             });
@@ -314,7 +314,7 @@ export class AgentWorkflowProcessor {
                 const lines = data.toString().trim().split('\n');
                 for (const line of lines) {
                     if (line) {
-                        logError(`  [${feature.name}] ${line}`);
+                        logError(`  [${issue.name}] ${line}`);
                     }
                 }
             });
@@ -323,7 +323,7 @@ export class AgentWorkflowProcessor {
             // Handle worker IPC messages
             worker.on('message', (msg) => {
                 if (msg.type === 'log') {
-                    const prefix = `[${feature.name}]`;
+                    const prefix = `[${issue.name}]`;
                     switch (msg.level) {
                         case 'info':
                             logInfo(`  ${prefix} ${msg.message}`);
@@ -344,29 +344,29 @@ export class AgentWorkflowProcessor {
                 }
                 else if (msg.type === 'result') {
                     resultReceived = true;
-                    this.handleWorkerResult(featureId, feature.name, msg.success ?? false, msg.error);
+                    this.handleWorkerResult(issueId, issue.name, msg.success ?? false, msg.error);
                 }
             });
             // Handle worker exit (crash, killed, etc.)
             worker.on('exit', (code) => {
                 // Clear timeout timer
-                const w = this.activeWorkers.get(featureId);
+                const w = this.activeWorkers.get(issueId);
                 if (w?.timeoutTimer) {
                     clearTimeout(w.timeoutTimer);
                 }
-                this.activeWorkers.delete(featureId);
+                this.activeWorkers.delete(issueId);
                 // If the worker exited without sending a result message, treat as failure
                 if (!resultReceived) {
                     if (code !== 0) {
-                        logError(`Worker for ${feature.name} exited with code ${code}`);
+                        logError(`Worker for ${issue.name} exited with code ${code}`);
                     }
-                    this.handleWorkerResult(featureId, feature.name, false, `Worker exited with code ${code}`);
+                    this.handleWorkerResult(issueId, issue.name, false, `Worker exited with code ${code}`);
                 }
             });
             // Set up worker timeout
             const { workerTimeout } = this.config.workflow;
             activeWorker.timeoutTimer = setTimeout(() => {
-                logError(`Worker for ${feature.name} timed out after ${Math.round(workerTimeout / 1000)}s, killing...`);
+                logError(`Worker for ${issue.name} timed out after ${Math.round(workerTimeout / 1000)}s, killing...`);
                 try {
                     worker.kill('SIGTERM');
                     // Force kill after 10s if SIGTERM didn't work
@@ -382,57 +382,57 @@ export class AgentWorkflowProcessor {
                 catch {
                     // Worker may already be dead
                 }
-                const err = new WorkerTimeoutError(featureId, workerTimeout);
-                this.handleWorkerResult(featureId, feature.name, false, err.message);
+                const err = new WorkerTimeoutError(issueId, workerTimeout);
+                this.handleWorkerResult(issueId, issue.name, false, err.message);
             }, workerTimeout);
             // Send start message to worker
             worker.send({
                 type: 'start',
-                featureId,
+                issueId,
                 verbose: this.options.verbose,
                 config: this.config,
             });
-            // Notify chat worker that a feature has started processing
+            // Notify chat worker that an issue has started processing
             this.notifyChatWorker({
-                type: 'event:feature_started',
-                featureId,
+                type: 'event:issue_started',
+                issueId,
                 repoPath,
             });
         }
         catch (error) {
-            this.activeWorkers.delete(featureId);
-            this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-            logError(`Feature error: ${feature.name} - ${error instanceof Error ? error.message : String(error)}`);
+            this.activeWorkers.delete(issueId);
+            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
+            logError(`Issue error: ${issue.name} - ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    handleWorkerResult(featureId, featureName, success, error) {
+    handleWorkerResult(issueId, issueName, success, error) {
         if (success) {
-            this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createCompletedState(featureId, currentState));
-            logSuccess(`Feature completed: ${featureName}`);
-            // Notify chat worker that feature workflow is done
-            this.notifyChatWorker({ type: 'event:feature_done', featureId });
+            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createCompletedState(issueId, currentState));
+            logSuccess(`Issue completed: ${issueName}`);
+            // Notify chat worker that issue workflow is done
+            this.notifyChatWorker({ type: 'event:issue_done', issueId });
         }
         else {
-            this.processedFeatures = updateFeatureState(this.processedFeatures, featureId, (currentState) => createFailedState(featureId, currentState));
-            logError(`Feature failed: ${featureName}${error ? ` - ${error}` : ''}`);
+            this.processedIssues = updateIssueState(this.processedIssues, issueId, (currentState) => createFailedState(issueId, currentState));
+            logError(`Issue failed: ${issueName}${error ? ` - ${error}` : ''}`);
             // Only notify chat on first failure to avoid flooding with duplicate messages
-            const failedState = this.processedFeatures.get(featureId);
+            const failedState = this.processedIssues.get(issueId);
             if (failedState && failedState.retryCount <= 1) {
                 this.notifyChatWorker({
                     type: 'event:phase_failed',
-                    featureId,
+                    issueId,
                     phase: 'workflow',
                     error: error || 'Unknown error',
                 });
             }
         }
-        // Clear heartbeat feature info
+        // Clear heartbeat issue info
         sendHeartbeat().catch(() => {
             /* noop */
         });
     }
     getStats() {
-        return calculateStats(this.processedFeatures, this.isRunning);
+        return calculateStats(this.processedIssues, this.isRunning);
     }
     getActiveWorkerCount() {
         return this.activeWorkers.size;

package/dist/commands/build/index.js

@@ -7,7 +7,7 @@ import { getGitHubConfigByProduct } from '../../api/github.js';
 import { getProduct } from '../../api/products.js';
 import { deregisterSession, registerSession, } from '../../system/session-manager.js';
 import { logInfo, logSuccess, logWarning } from '../../utils/logger.js';
-import { cloneFeatureRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
 import { analyzeBuildPlan, } from './detect-project.js';
 /** Default (real) implementations of all dependencies. */
 export function createDefaultDeps() {
@@ -15,7 +15,7 @@ export function createDefaultDeps() {
         fetchConfigs: getAppStoreConfigs,
         fetchProduct: getProduct,
         fetchGitHub: getGitHubConfigByProduct,
-        cloneRepo: (workspaceRoot, dirName, owner, repo, token) => cloneFeatureRepo(workspaceRoot, dirName, owner, repo, token),
+        cloneRepo: (workspaceRoot, dirName, owner, repo, token) => cloneIssueRepo(workspaceRoot, dirName, owner, repo, token),
         getWorkspaceRoot: ensureWorkspaceDir,
         saveBuildConfig: updateBuildConfig,
         checkoutDefaultBranch: checkoutDefaultBranchImpl,

package/dist/commands/find-bugs/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI command: edsger find-bugs <productId>
+ * Audits the product's repository for bugs and files each new finding as an issue.
+ */
+export interface FindBugsCliOptions {
+    full?: boolean;
+    branch?: string;
+    maxFiles?: number;
+    verbose?: boolean;
+}
+export declare function runFindBugs(productId: string, options: FindBugsCliOptions): Promise<void>;

package/dist/commands/find-bugs/index.js

@@ -0,0 +1,39 @@
+/**
+ * CLI command: edsger find-bugs <productId>
+ * Audits the product's repository for bugs and files each new finding as an issue.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { scanForBugs } from '../../phases/find-bugs/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runFindBugs(productId, options) {
+    const { full, branch, maxFiles, verbose } = options;
+    logInfo(`Starting bug scan for product ${productId}`);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await scanForBugs({
+        productId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        full,
+        branch,
+        maxFiles,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        if (result.summary) {
+            logInfo(result.summary);
+        }
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/find-features/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CLI command: edsger find-features <productId>
+ * Synthesises feature opportunities from user feedback + intelligence reports +
+ * the codebase, and files each one as an issue.
+ */
+export interface FindFeaturesCliOptions {
+    branch?: string;
+    since?: string;
+    minClusterSize?: number;
+    maxSuggestions?: number;
+    againstReport?: string;
+    verbose?: boolean;
+}
+export declare function runFindFeatures(productId: string, options: FindFeaturesCliOptions): Promise<void>;

package/dist/commands/find-features/index.js

@@ -0,0 +1,42 @@
+/**
+ * CLI command: edsger find-features <productId>
+ * Synthesises feature opportunities from user feedback + intelligence reports +
+ * the codebase, and files each one as an issue.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { scanForFeatures } from '../../phases/find-features/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runFindFeatures(productId, options) {
+    const { branch, since, minClusterSize, maxSuggestions, againstReport, verbose, } = options;
+    logInfo(`Starting feature discovery for product ${productId}`);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await scanForFeatures({
+        productId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        branch,
+        since,
+        minClusterSize,
+        maxSuggestions,
+        focusReportId: againstReport,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        if (result.summary) {
+            logInfo(result.summary);
+        }
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/find-smells/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CLI command: edsger find-smells <productId>
+ * Audits the product's repository for code smells (refactor candidates, perf
+ * cliffs, dead code, etc.) and files each new finding as an issue.
+ */
+import { type SmellCategory } from '../../phases/find-smells/types.js';
+export interface FindSmellsCliOptions {
+    full?: boolean;
+    branch?: string;
+    maxFiles?: number;
+    categories?: SmellCategory[];
+    verbose?: boolean;
+}
+/**
+ * Parse and validate `--categories` from the CLI. Throws on invalid input so
+ * commander's option-parser rejects the run before any work starts. Empty
+ * input is treated as "no filter" (returns undefined) rather than an error —
+ * matches user intuition for `--categories=`.
+ */
+export declare function parseCategoriesOption(raw: string): SmellCategory[] | undefined;
+export declare function runFindSmells(productId: string, options: FindSmellsCliOptions): Promise<void>;

package/dist/commands/find-smells/index.js

@@ -0,0 +1,65 @@
+/**
+ * CLI command: edsger find-smells <productId>
+ * Audits the product's repository for code smells (refactor candidates, perf
+ * cliffs, dead code, etc.) and files each new finding as an issue.
+ */
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { scanForSmells } from '../../phases/find-smells/index.js';
+import { isSmellCategory, SMELL_CATEGORIES, } from '../../phases/find-smells/types.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+/**
+ * Parse and validate `--categories` from the CLI. Throws on invalid input so
+ * commander's option-parser rejects the run before any work starts. Empty
+ * input is treated as "no filter" (returns undefined) rather than an error —
+ * matches user intuition for `--categories=`.
+ */
+export function parseCategoriesOption(raw) {
+    const tokens = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (tokens.length === 0) {
+        return undefined;
+    }
+    const invalid = tokens.filter((t) => !isSmellCategory(t));
+    if (invalid.length > 0) {
+        throw new Error(`--categories: unknown value(s): ${invalid.join(', ')}. ` +
+            `Allowed: ${SMELL_CATEGORIES.join(', ')}`);
+    }
+    // Dedup while preserving order so the error message and downstream behaviour
+    // are deterministic.
+    return Array.from(new Set(tokens));
+}
+export async function runFindSmells(productId, options) {
+    const { full, branch, maxFiles, categories, verbose } = options;
+    logInfo(`Starting smell scan for product ${productId}`);
+    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await scanForSmells({
+        productId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        full,
+        branch,
+        maxFiles,
+        categories,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        if (result.summary) {
+            logInfo(result.summary);
+        }
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/init/prompts.js

@@ -22,7 +22,7 @@ Please explore the codebase and create a markdown document covering:
 1. **Project Name** - Extract from package.json or similar
 2. **Description** - What the project does (from package.json description or README)
 3. **Goals and Objectives** - Infer from the codebase purpose
-4. **Core Features** - List main features by analyzing code structure
+4. **Core Issues** - List main issues by analyzing code structure
 5. **Target Users** - Who would use this project
 6. **Key Business Logic** - Important business rules or logic patterns
 7. **Important Notes** - Any critical information for developers

package/dist/commands/init/templates.d.ts

@@ -2,7 +2,7 @@
  * Template files for .edsger directory initialization
  * These files help edsger phases understand the project context
  */
-export declare const projectOverviewTemplate = "# Project Overview\n\n## Project Name\n[Your project name]\n\n## Description\n[Brief description of what this project does]\n\n## Goals and Objectives\n- [Goal 1]\n- [Goal 2]\n- [Goal 3]\n\n## Core Features\n1. **[Feature 1]**: [Description]\n2. **[Feature 2]**: [Description]\n3. **[Feature 3]**: [Description]\n\n## Target Users\n[Who uses this project?]\n\n## Key Business Logic\n[Describe the core business logic and rules]\n\n## Important Notes\n[Any critical information that developers should know]\n";
+export declare const projectOverviewTemplate = "# Project Overview\n\n## Project Name\n[Your project name]\n\n## Description\n[Brief description of what this project does]\n\n## Goals and Objectives\n- [Goal 1]\n- [Goal 2]\n- [Goal 3]\n\n## Core Issues\n1. **[Issue 1]**: [Description]\n2. **[Issue 2]**: [Description]\n3. **[Issue 3]**: [Description]\n\n## Target Users\n[Who uses this project?]\n\n## Key Business Logic\n[Describe the core business logic and rules]\n\n## Important Notes\n[Any critical information that developers should know]\n";
 export declare const techStackTemplate = "# Technology Stack\n\n## Programming Languages\n- [Language 1]: [Version and usage]\n- [Language 2]: [Version and usage]\n\n## Frameworks and Libraries\n\n### Frontend (if applicable)\n- [Framework]: [Version]\n- [Library 1]: [Usage]\n- [Library 2]: [Usage]\n\n### Backend (if applicable)\n- [Framework]: [Version]\n- [Library 1]: [Usage]\n- [Library 2]: [Usage]\n\n### Database\n- [Database]: [Version and purpose]\n- [ORM/Query builder]: [If applicable]\n\n## Development Tools\n- Package Manager: [npm/yarn/pnpm]\n- Build Tool: [Webpack/Vite/etc]\n- Testing Framework: [Jest/Vitest/Playwright/etc]\n- Linting: [ESLint/etc]\n- Formatting: [Prettier/etc]\n\n## Infrastructure\n- Hosting: [Platform]\n- CI/CD: [Tool]\n- Monitoring: [Tool]\n\n## External Services and APIs\n- [Service 1]: [Purpose]\n- [Service 2]: [Purpose]\n\n## Environment Variables\n```\n[List key environment variables and their purposes]\n```\n";
 export declare const architectureTemplate = "# System Architecture\n\n## High-Level Architecture\n[Describe the overall architecture - monolith, microservices, etc.]\n\n## Directory Structure\n```\nproject-root/\n\u251C\u2500\u2500 [directory 1]/  # [Purpose]\n\u251C\u2500\u2500 [directory 2]/  # [Purpose]\n\u2514\u2500\u2500 [directory 3]/  # [Purpose]\n```\n\n## Key Components\n\n### [Component 1]\n- **Location**: [Path]\n- **Purpose**: [What it does]\n- **Dependencies**: [What it depends on]\n\n### [Component 2]\n- **Location**: [Path]\n- **Purpose**: [What it does]\n- **Dependencies**: [What it depends on]\n\n## Data Flow\n[Describe how data flows through the system]\n\n## Integration Points\n- [External system 1]: [How it integrates]\n- [External system 2]: [How it integrates]\n\n## Design Patterns\n[List key design patterns used in the project]\n\n## Key Design Decisions\n1. **[Decision 1]**: [Rationale]\n2. **[Decision 2]**: [Rationale]\n\n## Security Considerations\n[Key security measures and considerations]\n\n## Performance Considerations\n[Key performance optimization strategies]\n";
 export declare const codingGuidelinesTemplate = "# Coding Guidelines\n\n## Code Style\n\n### General Principles\n- [Principle 1]\n- [Principle 2]\n- [Principle 3]\n\n### Naming Conventions\n- **Files**: [Convention, e.g., kebab-case, PascalCase]\n- **Variables**: [Convention, e.g., camelCase]\n- **Functions**: [Convention, e.g., camelCase, descriptive verbs]\n- **Classes**: [Convention, e.g., PascalCase]\n- **Constants**: [Convention, e.g., UPPER_SNAKE_CASE]\n\n## File Organization\n[How files should be organized within directories]\n\n## Import Order\n[Standard order for imports]\n```typescript\n// Example:\n// 1. External libraries\n// 2. Internal modules\n// 3. Types\n// 4. Styles\n```\n\n## Function Guidelines\n- Maximum function length: [X lines]\n- Function complexity: [Guidelines]\n- Documentation: [When to add comments]\n\n## Error Handling\n[Standard error handling approach]\n\n## Testing Requirements\n- Unit tests: [Requirements]\n- Integration tests: [Requirements]\n- Test coverage: [Target percentage]\n\n## Code Review Checklist\n- [ ] Code follows style guidelines\n- [ ] Tests are included and passing\n- [ ] Documentation is updated\n- [ ] No security vulnerabilities\n- [ ] Performance considerations addressed\n\n## Common Patterns to Use\n[List common patterns used in this project]\n\n## Anti-Patterns to Avoid\n[List patterns that should be avoided]\n\n## Git Commit Guidelines\n- Format: [Convention, e.g., Conventional Commits]\n- Example: `feat: add user authentication`\n";

package/dist/commands/init/templates.js

@@ -15,10 +15,10 @@ export const projectOverviewTemplate = `# Project Overview
 - [Goal 2]
 - [Goal 3]
 
-## Core Features
-1. **[Feature 1]**: [Description]
-2. **[Feature 2]**: [Description]
-3. **[Feature 3]**: [Description]
+## Core Issues
+1. **[Issue 1]**: [Description]
+2. **[Issue 2]**: [Description]
+3. **[Issue 3]**: [Description]
 
 ## Target Users
 [Who uses this project?]