edsger 0.29.3 → 0.30.1

package/.claude/settings.local.json

@@ -1,28 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Read(//Users/steven/development/edsger/**)",
-      "Bash(npm run build)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(ls:*)",
-      "Bash(cat:*)",
-      "Bash(npm run typecheck:*)",
-      "Bash(git diff:*)",
-      "WebSearch",
-      "WebFetch(domain:supabase.com)",
-      "Bash(npm install:*)",
-      "Bash(grep:*)",
-      "Bash(npx supabase gen types typescript --help:*)",
-      "Bash(git -C /Users/steven/development/edsger status)",
-      "Bash(git -C /Users/steven/development/edsger diff)",
-      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
-      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
-    ],
-    "deny": [],
-    "ask": []
+      "Bash(npx tsc:*)",
+      "Bash(npm run:*)"
+    ]
   }
 }

package/dist/api/chat.d.ts

@@ -33,6 +33,24 @@ export declare function claimPendingMessages(channelId: string, workerId: string
 export declare function markMessageProcessed(messageId: string, verbose?: boolean): Promise<void>;
 export declare function markChannelRead(channelId: string, lastReadMessageId?: string, verbose?: boolean): Promise<void>;
 export declare function getUnreadCount(channelId: string, verbose?: boolean): Promise<number>;
+/**
+ * Get or create the group chat channel for a product.
+ * Every product has one group channel.
+ */
+export declare function getProductChannel(productId: string, verbose?: boolean): Promise<ChatChannel>;
+/**
+ * Send a system message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendProductSystemMessage(productId: string, content: string, metadata?: Record<string, unknown>, verbose?: boolean): Promise<ChatMessage>;
+/**
+ * Send an AI message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export declare function sendProductAiMessage(productId: string, content: string, metadata?: Record<string, unknown>, options?: {
+    messageType?: ChatMessageType;
+    parentMessageId?: string;
+}, verbose?: boolean): Promise<ChatMessage>;
 /**
  * Get or create the group chat channel for a feature.
  * This is the most common operation — every feature has one group channel.

package/dist/api/chat.js

@@ -135,6 +135,47 @@ export async function getUnreadCount(channelId, verbose) {
     return result.unread_count;
 }
 // ============================================================
+// Convenience: Product Channel
+// ============================================================
+/**
+ * Get or create the group chat channel for a product.
+ * Every product has one group channel.
+ */
+export async function getProductChannel(productId, verbose) {
+    const { channel } = await getOrCreateChannel('product', productId, 'group', undefined, verbose);
+    return channel;
+}
+/**
+ * Send a system message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendProductSystemMessage(productId, content, metadata = {}, verbose) {
+    try {
+        const channel = await getProductChannel(productId, verbose);
+        return await sendSystemMessage(channel.id, content, metadata, verbose);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to send system message for product ${productId}: ${msg}`);
+        throw error;
+    }
+}
+/**
+ * Send an AI message to a product's group channel.
+ * Creates the channel if it doesn't exist.
+ */
+export async function sendProductAiMessage(productId, content, metadata = {}, options = {}, verbose) {
+    try {
+        const channel = await getProductChannel(productId, verbose);
+        return await sendAiMessage(channel.id, content, metadata, options, verbose);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to send AI message for product ${productId}: ${msg}`);
+        throw error;
+    }
+}
+// ============================================================
 // Convenience: Feature Channel
 // ============================================================
 /**

package/dist/api/features/status-updater.d.ts

@@ -10,6 +10,10 @@ interface StatusUpdateOptions {
 }
 /**
  * Check if moving from currentStatus to newStatus is forward progression
+ *
+ * Special cases for archived status:
+ * - Any status → archived: Always allowed (archiving from any state)
+ * - Archived → backlog: Always allowed (unarchiving restores to backlog)
  */
 export declare function isForwardProgression(currentStatus: FeatureStatus, newStatus: FeatureStatus): boolean;
 /**

package/dist/api/features/status-updater.js

@@ -8,8 +8,18 @@ import { getFeature } from './get-feature.js';
 import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../../config/feature-status.js';
 /**
  * Check if moving from currentStatus to newStatus is forward progression
+ *
+ * Special cases for archived status:
+ * - Any status → archived: Always allowed (archiving from any state)
+ * - Archived → backlog: Always allowed (unarchiving restores to backlog)
  */
 export function isForwardProgression(currentStatus, newStatus) {
+    // Any status can transition to archived
+    if (newStatus === 'archived')
+        return true;
+    // Archived can only transition back to backlog (unarchive)
+    if (currentStatus === 'archived')
+        return newStatus === 'backlog';
     const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
     const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
     // Allow moving forward or staying at same level (for retries, etc.)

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

@@ -15,7 +15,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { getFeatureChannel, claimPendingMessages, listChannels, sendSystemMessage, } from '../../api/chat.js';
-import { processHumanMessages, processPhaseCompletion, } from '../../phases/chat-processor/index.js';
+import { processHumanMessages, processProductHumanMessages, processPhaseCompletion, } from '../../phases/chat-processor/index.js';
 function sendMessage(msg) {
     if (process.send) {
         process.send(msg);
@@ -35,6 +35,8 @@ let pollTimer = null;
 const WORKER_ID = `chat-worker-${process.pid}-${randomUUID().slice(0, 8)}`;
 // Track active feature channels (featureId -> 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();
 // Poll interval in ms
@@ -53,20 +55,33 @@ async function pollForMessages() {
     if (pollCount % CHANNEL_REFRESH_INTERVAL === 0) {
         await refreshChannels();
     }
+    // Poll feature channels
     for (const [featureId, channelId] of activeChannels) {
         try {
-            // Atomically claim messages — other workers won't see these
             const claimed = await claimPendingMessages(channelId, WORKER_ID);
             if (claimed.length > 0) {
                 log('info', `Claimed ${claimed.length} message(s) for feature ${featureId} (worker: ${WORKER_ID})`);
-                // Batch all claimed messages into a single AI session
                 const repoPath = featureRepoPaths.get(featureId);
                 await processHumanMessages(claimed, featureId, config, verbose, repoPath);
             }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            log('error', `Error polling channel ${channelId}: ${msg}`);
+            log('error', `Error polling feature channel ${channelId}: ${msg}`);
+        }
+    }
+    // Poll product channels
+    for (const [productId, channelId] of activeProductChannels) {
+        try {
+            const claimed = await claimPendingMessages(channelId, WORKER_ID);
+            if (claimed.length > 0) {
+                log('info', `Claimed ${claimed.length} message(s) for product ${productId} (worker: ${WORKER_ID})`);
+                await processProductHumanMessages(claimed, productId, config, verbose);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            log('error', `Error polling product channel ${channelId}: ${msg}`);
         }
     }
 }
@@ -161,16 +176,26 @@ async function handleFeatureDone(msg) {
  */
 async function refreshChannels() {
     try {
-        const channels = await listChannels('feature');
+        // Fetch feature and product channels in parallel
+        const [featureChannels, productChannels] = await Promise.all([
+            listChannels('feature'),
+            listChannels('product'),
+        ]);
         let added = 0;
-        for (const channel of channels) {
+        for (const channel of featureChannels) {
             if (channel.channel_ref_id && !activeChannels.has(channel.channel_ref_id)) {
                 activeChannels.set(channel.channel_ref_id, channel.id);
                 added++;
             }
         }
+        for (const channel of productChannels) {
+            if (channel.channel_ref_id && !activeProductChannels.has(channel.channel_ref_id)) {
+                activeProductChannels.set(channel.channel_ref_id, channel.id);
+                added++;
+            }
+        }
         if (added > 0) {
-            log('info', `Discovered ${added} new channel(s) (total: ${activeChannels.size})`);
+            log('info', `Discovered ${added} new channel(s) (features: ${activeChannels.size}, products: ${activeProductChannels.size})`);
         }
     }
     catch (error) {

package/dist/config/__tests__/feature-status.test.js

@@ -6,9 +6,9 @@ import assert from 'node:assert';
 import { STATUS_PROGRESSION_ORDER, PHASE_STATUS_MAP, } from '../feature-status.js';
 describe('Feature Status Configuration', () => {
     describe('STATUS_PROGRESSION_ORDER', () => {
-        it('should start with backlog and end with shipped', () => {
+        it('should start with backlog and end with archived', () => {
             assert.strictEqual(STATUS_PROGRESSION_ORDER[0], 'backlog', 'First status should be backlog');
-            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'shipped', 'Last status should be shipped');
+            assert.strictEqual(STATUS_PROGRESSION_ORDER[STATUS_PROGRESSION_ORDER.length - 1], 'archived', 'Last status should be archived');
         });
         it('should be readonly', () => {
             // This test ensures the configuration is properly typed as readonly

package/dist/config/feature-status.js

@@ -49,6 +49,7 @@ export const STATUS_PROGRESSION_ORDER = [
     'testing_failed',
     'ready_for_review',
     'shipped',
+    'archived',
 ];
 /**
  * Phase to status mapping
@@ -119,6 +120,7 @@ export const HUMAN_SELECTABLE_STATUSES = [
     'functional_testing',
     'ready_for_review',
     'shipped',
+    'archived',
 ];
 /**
  * Check if a status can be manually selected by a human user

package/dist/phases/autonomous/index.js

@@ -14,6 +14,7 @@ import { createBranches, getCurrentBranch, updateBranch, } from '../../services/
 import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
 import { createBranchPullRequest, } from '../code-implementation/branch-pr-creator.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { gitPush } from '../../utils/git-push.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { createAutonomousSystemPrompt, createAutonomousUserPrompt, } from './prompts.js';
 /**
@@ -35,59 +36,6 @@ async function* prompt(userPrompt) {
     yield userMessage(userPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-/**
- * Push branch to remote repository
- */
-async function pushToRemote(branchName, verbose) {
-    try {
-        const { execSync } = await import('child_process');
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch {
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch {
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    return { success: true };
-                }
-                catch (forceError) {
-                    return {
-                        success: false,
-                        error: forceError instanceof Error
-                            ? forceError.message
-                            : String(forceError),
-                    };
-                }
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
 /**
  * Run a single autonomous iteration using Claude Code SDK
  */
@@ -265,14 +213,19 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
             if (iterationResult.success) {
                 logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
-                // Push to remote
-                const pushResult = await pushToRemote(devBranchName, verbose);
+                // Get GitHub config for push authentication and PR creation
+                const githubConfig = await getGitHubConfig(featureId, verbose);
+                // Push to remote with authentication
+                const pushResult = gitPush({
+                    branchName: devBranchName,
+                    token: githubConfig.configured ? githubConfig.token : undefined,
+                    verbose,
+                });
                 if (!pushResult.success && verbose) {
                     logError(`⚠️  Failed to push: ${pushResult.error}`);
                 }
                 // Create PR after first successful iteration
                 if (!prUrl) {
-                    const githubConfig = await getGitHubConfig(featureId, verbose);
                     if (githubConfig.configured &&
                         githubConfig.token &&
                         githubConfig.owner &&

package/dist/phases/chat-processor/index.d.ts

@@ -27,6 +27,12 @@ export declare function clearChannelSession(channelId: string): void;
  * Returns the session ID (callers should track this if needed).
  */
 export declare function processHumanMessages(messages: ChatMessage[], featureId: string, config: EdsgerConfig, verbose?: boolean, repoPath?: string): Promise<string | undefined>;
+/**
+ * Process one or more human messages from a product channel.
+ * Same session resumption pattern as feature chat, but uses
+ * product context, product prompt, and product tools.
+ */
+export declare function processProductHumanMessages(messages: ChatMessage[], productId: string, config: EdsgerConfig, verbose?: boolean): Promise<string | undefined>;
 /**
  * Process a phase completion event: analyze output and suggest next steps.
  * Resumes the same channel session so AI has full conversation context.

package/dist/phases/chat-processor/index.js

@@ -15,8 +15,11 @@ import { DEFAULT_MODEL } from '../../constants.js';
 import { logInfo, logError } from '../../utils/logger.js';
 import { sendAiMessage, markMessageProcessed, sendSystemMessage, getFeatureChannel, listChatMessages, } from '../../api/chat.js';
 import { buildChatContext, formatContextForAI } from './context.js';
+import { buildProductChatContext, formatProductContextForAI, } from './product-context.js';
 import { CHAT_RESPONSE_PROMPT, NEXT_STEP_ADVISOR_PROMPT, buildNextStepAdvisorMessage, } from './prompts.js';
+import { PRODUCT_CHAT_RESPONSE_PROMPT } from './product-prompts.js';
 import { createChatMcpServer } from './tools.js';
+import { createProductChatMcpServer } from './product-tools.js';
 // ============================================================
 // Session Management
 // ============================================================
@@ -153,6 +156,109 @@ export async function processHumanMessages(messages, featureId, config, verbose,
         return undefined;
     }
 }
+/**
+ * Process one or more human messages from a product channel.
+ * Same session resumption pattern as feature chat, but uses
+ * product context, product prompt, and product tools.
+ */
+export async function processProductHumanMessages(messages, productId, config, verbose) {
+    if (messages.length === 0)
+        return undefined;
+    const channelId = messages[0].channel_id;
+    const existingSessionId = channelSessions.get(channelId);
+    if (verbose) {
+        logInfo(`Processing ${messages.length} product message(s) for channel ${channelId}` +
+            (existingSessionId ? ` (resuming session ${existingSessionId})` : ' (new session)'));
+    }
+    try {
+        // Build the user prompt
+        const messageParts = messages.map((m, i) => {
+            if (messages.length === 1) {
+                return m.content;
+            }
+            return `[Message ${i + 1} from ${m.sender_name}]: ${m.content}`;
+        });
+        const userPrompt = messageParts.join('\n\n');
+        let fullPrompt;
+        if (!existingSessionId) {
+            const context = await buildProductChatContext(productId, channelId, verbose);
+            const contextStr = formatProductContextForAI(context);
+            // Load recent chat history
+            const recentMessages = await listChatMessages(channelId, { limit: 30 }, verbose);
+            const currentIds = new Set(messages.map((m) => m.id));
+            const historyMessages = recentMessages.filter((m) => !currentIds.has(m.id));
+            let historySection = '';
+            if (historyMessages.length > 0) {
+                const historyLines = historyMessages.map((m) => {
+                    const role = m.sender_type === 'ai' ? 'AI' : m.sender_type === 'system' ? 'System' : (m.sender_name || 'User');
+                    return `[${role}]: ${m.content}`;
+                });
+                historySection = [
+                    `## Previous Chat History`,
+                    `The following is the recent conversation history in this channel. Continue the conversation naturally.`,
+                    '',
+                    ...historyLines,
+                    '',
+                ].join('\n');
+            }
+            fullPrompt = [
+                `## Current Product Context`,
+                contextStr,
+                '',
+                `## Channel ID: ${channelId}`,
+                `## Product ID: ${productId}`,
+                '',
+                historySection,
+                `## Human Message`,
+                userPrompt,
+                '',
+                `Respond to this message. Use tools if you need to take actions. Always respond in the chat using the send_chat_message tool.`,
+            ].join('\n');
+        }
+        else {
+            fullPrompt = userPrompt;
+        }
+        // Run the agent with product tools (no cwd — product chat doesn't operate on a repo)
+        const result = await runProductChatAgent(PRODUCT_CHAT_RESPONSE_PROMPT, fullPrompt, config, existingSessionId, verbose);
+        if (result.sessionId) {
+            channelSessions.set(channelId, result.sessionId);
+        }
+        const sentViaTool = result.toolsUsed.has('mcp__edsger-product-chat__send_chat_message');
+        if (result.text && !sentViaTool) {
+            await sendAiMessage(channelId, result.text, {
+                in_response_to: messages[messages.length - 1].id,
+            });
+        }
+        for (const message of messages) {
+            await markMessageProcessed(message.id, verbose);
+        }
+        if (verbose) {
+            logInfo(`All ${messages.length} product message(s) processed successfully`);
+        }
+        return result.sessionId;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logError(`Failed to process product messages: ${msg}`);
+        if (existingSessionId) {
+            logInfo(`Clearing session ${existingSessionId} and retrying without resume`);
+            channelSessions.delete(channelId);
+            return processProductHumanMessages(messages, productId, config, verbose);
+        }
+        try {
+            await sendAiMessage(channelId, `Sorry, I encountered an error processing your message: ${msg}`, {
+                error: true,
+            });
+        }
+        catch {
+            // Ignore error sending error message
+        }
+        for (const message of messages) {
+            await markMessageProcessed(message.id, verbose);
+        }
+        return undefined;
+    }
+}
 /**
  * Process a phase completion event: analyze output and suggest next steps.
  * Resumes the same channel session so AI has full conversation context.
@@ -309,3 +415,61 @@ async function runChatAgent(systemPrompt, userPrompt, config, resumeSessionId, v
         toolsUsed: toolUsed,
     };
 }
+/**
+ * Run the Claude Agent SDK with product chat MCP tools.
+ * Same as runChatAgent but uses product-level tools instead of feature-level tools.
+ * No cwd parameter since product chat doesn't operate on a specific repo.
+ */
+async function runProductChatAgent(systemPrompt, userPrompt, config, resumeSessionId, verbose) {
+    let lastAssistantResponse = '';
+    const toolUsed = new Set();
+    let sessionId;
+    const productChatMcpServer = createProductChatMcpServer();
+    for await (const message of query({
+        prompt: prompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 20,
+            permissionMode: 'bypassPermissions',
+            mcpServers: {
+                'edsger-product-chat': productChatMcpServer,
+            },
+            ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+        },
+    })) {
+        if (message.session_id && !sessionId) {
+            sessionId = message.session_id;
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += content.text + '\n';
+                    if (verbose) {
+                        console.log(`🤖 ${content.text}`);
+                    }
+                }
+                else if (content.type === 'tool_use') {
+                    toolUsed.add(content.name);
+                    if (verbose) {
+                        console.log(`🔧 Tool: ${content.name}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (verbose) {
+                logInfo(`Product chat agent completed: ${message.subtype}`);
+            }
+        }
+    }
+    return {
+        text: lastAssistantResponse.trim(),
+        sessionId,
+        toolsUsed: toolUsed,
+    };
+}

package/dist/phases/chat-processor/product-context.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Build context for the product chat AI processor.
+ * Fetches product state, features summary, and recent chat history.
+ */
+import type { ChatMessage } from '../../types/index.js';
+export interface ProductChatContext {
+    productId: string;
+    productName: string;
+    productDescription: string;
+    featuresSummary: {
+        total: number;
+        byStatus: Record<string, number>;
+        features: Array<{
+            id: string;
+            name: string;
+            status: string;
+            description: string;
+        }>;
+    };
+    teamMembers: Array<{
+        id: string;
+        name: string;
+        email: string;
+        role: string;
+    }>;
+    recentChatMessages: ChatMessage[];
+    channelId: string;
+}
+/**
+ * Build the full context for the product chat AI to process a message.
+ */
+export declare function buildProductChatContext(productId: string, channelId: string, verbose?: boolean): Promise<ProductChatContext>;
+/**
+ * Format product context into a string for the AI system prompt.
+ */
+export declare function formatProductContextForAI(context: ProductChatContext): string;