edsger 0.50.0 → 0.52.0

package/dist/commands/agent-workflow/chat-worker.js

@@ -1,20 +1,20 @@
 /**
  * Chat Worker — Child process entry point for processing chat messages.
  *
- * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside feature workers.
- * Runs continuously, polling for unprocessed human messages across all active feature channels.
+ * Spawned by AgentWorkflowProcessor as a parallel subprocess alongside issue workers.
+ * Runs continuously, polling for unprocessed human messages across all active issue channels.
  *
  * Communication with parent via IPC:
  * - Parent sends: { type: 'init', config }
- * - Parent sends: { type: 'event:phase_completed', featureId, phase, summary, phaseOutput }
- * - Parent sends: { type: 'event:phase_failed', featureId, phase, error }
- * - Parent sends: { type: 'event:feature_done', featureId }
+ * - Parent sends: { type: 'event:phase_completed', issueId, phase, summary, phaseOutput }
+ * - Parent sends: { type: 'event:phase_failed', issueId, phase, error }
+ * - Parent sends: { type: 'event:issue_done', issueId }
  * - Worker sends: { type: 'log', level, message }
- * - Worker sends: { type: 'command:pause_feature', featureId }
- * - Worker sends: { type: 'command:resume_feature', featureId }
+ * - Worker sends: { type: 'command:pause_issue', issueId }
+ * - Worker sends: { type: 'command:resume_issue', issueId }
  */
 import { randomUUID } from 'node:crypto';
-import { claimPendingMessages, getFeatureChannel, listChannels, sendSystemMessage, } from '../../api/chat.js';
+import { claimPendingMessages, getIssueChannel, listChannels, sendSystemMessage, } from '../../api/chat.js';
 import { processHumanMessages, processPhaseCompletion, processProductHumanMessages, } from '../../phases/chat-processor/index.js';
 function sendMessage(msg) {
     if (process.send) {
@@ -33,12 +33,12 @@ let isRunning = false;
 let pollTimer = null;
 // Unique worker ID for this process instance — used for atomic message claiming
 const WORKER_ID = `chat-worker-${process.pid}-${randomUUID().slice(0, 8)}`;
-// Track active feature channels (featureId -> channelId)
+// Track active issue channels (issueId -> channelId)
 const activeChannels = new Map();
 // Track active product channels (productId -> channelId)
 const activeProductChannels = new Map();
-// Track feature repo paths (featureId -> repoPath) for setting cwd on AI agent
-const featureRepoPaths = new Map();
+// Track issue repo paths (issueId -> repoPath) for setting cwd on AI agent
+const issueRepoPaths = new Map();
 // Poll interval in ms
 const POLL_INTERVAL = 5000;
 // Refresh channel list every N polls (~30s at 5s intervals)
@@ -56,19 +56,19 @@ async function pollForMessages() {
     if (pollCount % CHANNEL_REFRESH_INTERVAL === 0) {
         await refreshChannels();
     }
-    // Poll feature channels
-    for (const [featureId, channelId] of activeChannels) {
+    // Poll issue channels
+    for (const [issueId, channelId] of activeChannels) {
         try {
             const claimed = await claimPendingMessages(channelId, WORKER_ID);
             if (claimed.length > 0) {
-                log('info', `Claimed ${claimed.length} message(s) for feature ${featureId} (worker: ${WORKER_ID})`);
-                const repoPath = featureRepoPaths.get(featureId);
-                await processHumanMessages(claimed, featureId, config, verbose, repoPath);
+                log('info', `Claimed ${claimed.length} message(s) for issue ${issueId} (worker: ${WORKER_ID})`);
+                const repoPath = issueRepoPaths.get(issueId);
+                await processHumanMessages(claimed, issueId, config, verbose, repoPath);
             }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            log('error', `Error polling feature channel ${channelId}: ${msg}`);
+            log('error', `Error polling issue channel ${channelId}: ${msg}`);
         }
     }
     // Poll product channels
@@ -127,15 +127,15 @@ async function handlePhaseCompleted(msg) {
     if (!config) {
         return;
     }
-    const { featureId, phase, summary, phaseOutput } = msg;
-    log('info', `Phase completed: ${phase} for feature ${featureId}`);
+    const { issueId, phase, summary, phaseOutput } = msg;
+    log('info', `Phase completed: ${phase} for issue ${issueId}`);
     try {
         // Ensure we have the channel registered
-        await ensureFeatureChannel(featureId);
+        await ensureIssueChannel(issueId);
         // Process with AI for next-step suggestions
-        const repoPath = featureRepoPaths.get(featureId);
+        const repoPath = issueRepoPaths.get(issueId);
         await processPhaseCompletion({
-            featureId,
+            issueId,
             phase,
             summary,
             phaseOutput,
@@ -150,11 +150,11 @@ async function handlePhaseCompleted(msg) {
     }
 }
 async function handlePhaseFailed(msg) {
-    const { featureId, phase, error: errorStr } = msg;
-    log('warning', `Phase failed: ${phase} for feature ${featureId}`);
+    const { issueId, phase, error: errorStr } = msg;
+    log('warning', `Phase failed: ${phase} for issue ${issueId}`);
     try {
-        await ensureFeatureChannel(featureId);
-        const channelId = activeChannels.get(featureId);
+        await ensureIssueChannel(issueId);
+        const channelId = activeChannels.get(issueId);
         if (channelId) {
             await sendSystemMessage(channelId, `Phase "${phase}" failed: ${errorStr}`, { phase, status: 'failed', error: errorStr });
         }
@@ -164,14 +164,14 @@ async function handlePhaseFailed(msg) {
         log('error', `Failed to send phase failure message: ${errorMsg}`);
     }
 }
-async function handleFeatureDone(msg) {
-    const { featureId } = msg;
-    log('info', `Feature done: ${featureId}`);
+async function handleIssueDone(msg) {
+    const { issueId } = msg;
+    log('info', `Issue done: ${issueId}`);
     try {
-        const channelId = activeChannels.get(featureId);
+        const channelId = activeChannels.get(issueId);
         if (channelId) {
             await sendSystemMessage(channelId, 'All workflow phases completed.', {
-                status: 'feature_done',
+                status: 'issue_done',
             });
         }
     }
@@ -186,17 +186,17 @@ async function handleFeatureDone(msg) {
 /**
  * Refresh the active channels list from the server.
  * Called on init and periodically during polling to discover
- * newly created channels (e.g., when a user opens a feature chat on the web).
+ * newly created channels (e.g., when a user opens an issue chat on the web).
  */
 async function refreshChannels() {
     try {
-        // Fetch feature and product channels in parallel
-        const [featureChannels, productChannels] = await Promise.all([
-            listChannels('feature'),
+        // Fetch issue and product channels in parallel
+        const [issueChannels, productChannels] = await Promise.all([
+            listChannels('issue'),
             listChannels('product'),
         ]);
         let added = 0;
-        for (const channel of featureChannels) {
+        for (const channel of issueChannels) {
             if (channel.channel_ref_id &&
                 !activeChannels.has(channel.channel_ref_id)) {
                 activeChannels.set(channel.channel_ref_id, channel.id);
@@ -211,7 +211,7 @@ async function refreshChannels() {
             }
         }
         if (added > 0) {
-            log('info', `Discovered ${added} new channel(s) (features: ${activeChannels.size}, products: ${activeProductChannels.size})`);
+            log('info', `Discovered ${added} new channel(s) (issues: ${activeChannels.size}, products: ${activeProductChannels.size})`);
         }
     }
     catch (error) {
@@ -219,20 +219,20 @@ async function refreshChannels() {
         log('error', `Failed to refresh channels: ${msg}`);
     }
 }
-async function ensureFeatureChannel(featureId) {
-    const cachedChannel = activeChannels.get(featureId);
+async function ensureIssueChannel(issueId) {
+    const cachedChannel = activeChannels.get(issueId);
     if (cachedChannel) {
         return cachedChannel;
     }
     try {
-        const channel = await getFeatureChannel(featureId);
-        activeChannels.set(featureId, channel.id);
-        log('info', `Registered channel ${channel.id} for feature ${featureId}`);
+        const channel = await getIssueChannel(issueId);
+        activeChannels.set(issueId, channel.id);
+        log('info', `Registered channel ${channel.id} for issue ${issueId}`);
         return channel.id;
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        log('error', `Failed to get channel for feature ${featureId}: ${msg}`);
+        log('error', `Failed to get channel for issue ${issueId}: ${msg}`);
         throw error;
     }
 }
@@ -256,18 +256,18 @@ process.on('message', (msg) => {
                 log('error', `Phase fail event error: ${error instanceof Error ? error.message : String(error)}`);
             });
             break;
-        case 'event:feature_done':
-            handleFeatureDone(msg).catch((error) => {
-                log('error', `Feature done event error: ${error instanceof Error ? error.message : String(error)}`);
+        case 'event:issue_done':
+            handleIssueDone(msg).catch((error) => {
+                log('error', `Issue done event error: ${error instanceof Error ? error.message : String(error)}`);
             });
             break;
-        // Register a feature channel for polling when a worker starts
-        case 'event:feature_started': {
+        // Register an issue channel for polling when a worker starts
+        case 'event:issue_started': {
             const startMsg = msg;
             if (startMsg.repoPath) {
-                featureRepoPaths.set(startMsg.featureId, startMsg.repoPath);
+                issueRepoPaths.set(startMsg.issueId, startMsg.repoPath);
             }
-            ensureFeatureChannel(startMsg.featureId).catch((error) => {
+            ensureIssueChannel(startMsg.issueId).catch((error) => {
                 log('error', `Channel registration error: ${error instanceof Error ? error.message : String(error)}`);
             });
             break;

package/dist/commands/agent-workflow/index.d.ts

@@ -3,9 +3,9 @@
  *
  * This is the new cross-product workflow that:
  * 1. Uses stored auth from `edsger login` (no per-repo env config needed)
- * 2. Fetches ready_for_ai features across ALL products
+ * 2. Fetches ready_for_ai issues across ALL products
  * 3. Clones repos using GitHub App installation tokens
- * 4. Manages workspace directories with feature ID naming
+ * 4. Manages workspace directories with issue ID naming
  * 5. Runs continuously with auto-update, sleep prevention, and session management
  * 6. Responds to web dashboard commands (pause/resume/stop)
  */

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

@@ -3,9 +3,9 @@
  *
  * This is the new cross-product workflow that:
  * 1. Uses stored auth from `edsger login` (no per-repo env config needed)
- * 2. Fetches ready_for_ai features across ALL products
+ * 2. Fetches ready_for_ai issues across ALL products
  * 3. Clones repos using GitHub App installation tokens
- * 4. Manages workspace directories with feature ID naming
+ * 4. Manages workspace directories with issue ID naming
  * 5. Runs continuously with auto-update, sleep prevention, and session management
  * 6. Responds to web dashboard commands (pause/resume/stop)
  */
@@ -45,7 +45,7 @@ export async function runAgentWorkflow(options) {
     // Start heartbeat
     startHeartbeat();
     logRaw('');
-    logSuccess('Agent started. Watching for features...');
+    logSuccess('Agent started. Watching for issues...');
     logRaw('');
     // Create and start the processor
     let maxConcurrent = 3;

package/dist/commands/agent-workflow/{feature-worker.d.ts → issue-worker.d.ts}

@@ -1,14 +1,14 @@
 /**
- * Feature Worker - Child process entry point for processing a single feature
+ * Issue Worker - Child process entry point for processing a single issue
  *
  * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
  * Each worker runs in its own process with its own cwd, which:
- * 1. Allows concurrent feature processing (no shared process.chdir())
+ * 1. Allows concurrent issue processing (no shared process.chdir())
  * 2. After auto-update, new workers load the latest code from disk
  *
  * Communication with parent via IPC messages:
- * - Parent sends: { type: 'start', featureId, verbose, config }
- * - Worker sends: { type: 'result', success: boolean, featureId }
+ * - Parent sends: { type: 'start', issueId, verbose, config }
+ * - Worker sends: { type: 'result', success: boolean, issueId }
  * - Worker sends: { type: 'log', level, message } for logging
  */
 export {};

package/dist/commands/agent-workflow/{feature-worker.js → issue-worker.js}

@@ -1,18 +1,18 @@
 /**
- * Feature Worker - Child process entry point for processing a single feature
+ * Issue Worker - Child process entry point for processing a single issue
  *
  * This file is spawned by the parent AgentWorkflowProcessor via child_process.fork().
  * Each worker runs in its own process with its own cwd, which:
- * 1. Allows concurrent feature processing (no shared process.chdir())
+ * 1. Allows concurrent issue processing (no shared process.chdir())
  * 2. After auto-update, new workers load the latest code from disk
  *
  * Communication with parent via IPC messages:
- * - Parent sends: { type: 'start', featureId, verbose, config }
- * - Worker sends: { type: 'result', success: boolean, featureId }
+ * - Parent sends: { type: 'start', issueId, verbose, config }
+ * - Worker sends: { type: 'result', success: boolean, issueId }
  * - Worker sends: { type: 'log', level, message } for logging
  */
 import { evaluatePipelineResults } from '../workflow/core/pipeline-evaluator.js';
-import { runFeatureWorkflow } from '../workflow/feature-coordinator.js';
+import { runIssueWorkflow } from '../workflow/issue-coordinator.js';
 function sendMessage(msg) {
     if (process.send) {
         process.send(msg);
@@ -22,23 +22,23 @@ function log(level, message) {
     sendMessage({ type: 'log', level, message });
 }
 async function handleStart(msg) {
-    const { featureId, verbose, config } = msg;
+    const { issueId, verbose, config } = msg;
     try {
-        log('info', `Worker started for feature: ${featureId}`);
-        const results = await runFeatureWorkflow({ featureId, verbose }, config);
+        log('info', `Worker started for issue: ${issueId}`);
+        const results = await runIssueWorkflow({ issueId, verbose }, config);
         const allSuccessful = evaluatePipelineResults(results);
         sendMessage({
             type: 'result',
-            featureId,
+            issueId,
             success: allSuccessful,
         });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        log('error', `Worker error for feature ${featureId}: ${errorMessage}`);
+        log('error', `Worker error for issue ${issueId}: ${errorMessage}`);
         sendMessage({
             type: 'result',
-            featureId,
+            issueId,
             success: false,
             error: errorMessage,
         });
@@ -57,7 +57,7 @@ process.on('message', (msg) => {
 process.on('uncaughtException', (error) => {
     sendMessage({
         type: 'result',
-        featureId: 'unknown',
+        issueId: 'unknown',
         success: false,
         error: `Uncaught exception: ${error.message}`,
     });

package/dist/commands/agent-workflow/processor.d.ts

@@ -1,10 +1,10 @@
 /**
- * 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 { type EdsgerConfig } from '../../types/index.js';
@@ -29,9 +29,9 @@ export declare class AgentWorkflowProcessor {
     private readonly options;
     private readonly config;
     private isRunning;
-    private processedFeatures;
+    private processedIssues;
     private pollTimer?;
-    /** Currently active worker processes, keyed by featureId */
+    /** Currently active worker processes, keyed by issueId */
     private activeWorkers;
     /** Chat worker subprocess — runs in parallel, handles chat messages and phase events */
     private chatWorker?;
@@ -41,12 +41,12 @@ export declare class AgentWorkflowProcessor {
     /** Send a message to the chat worker via IPC */
     private notifyChatWorker;
     stop(): void;
-    private processNextFeatures;
+    private processNextIssues;
     /**
-     * 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.
      */
-    private startFeatureWorker;
+    private startIssueWorker;
     private handleWorkerResult;
     getStats(): WorkflowStats;
     getActiveWorkerCount(): number;