ticket-to-pr 1.4.0 → 1.4.1

package/dist/index.js

@@ -52,6 +52,7 @@ function log(color, label, msg) {
 const reviewPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'review.md'), 'utf-8');
 const executePrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'execute.md'), 'utf-8');
 const diffReviewPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'diff-review.md'), 'utf-8');
+const retroPrompt = readFileSync(join(PACKAGE_ROOT, 'prompts', 'retro.md'), 'utf-8');
 // -- Agent Runner --
 async function runReviewAgent(ticket) {
     const projectDir = getProjectDir(ticket.project);
@@ -275,6 +276,108 @@ async function runDiffReviewAgent(worktreeDir, baseBranch, spec, description, af
         cost,
     };
 }
+async function runRetroAgent(projectDir, worktreeDir, baseBranch, ticket, outcome) {
+    try {
+        // Get the diff (may be empty if agent failed before committing)
+        let diff = '';
+        try {
+            diff = execSync(`git diff origin/${shellEscape(baseBranch)}...HEAD`, {
+                cwd: worktreeDir, stdio: 'pipe', timeout: 15_000,
+            }).toString();
+        }
+        catch {
+            // No diff available
+        }
+        // Read existing learnings to avoid repeats
+        const existingLearnings = readLearnings(projectDir);
+        // Build the retro prompt
+        const parts = [
+            retroPrompt,
+            '',
+            `## Ticket: ${ticket.title}`,
+            '',
+            '**Description**:',
+            ticket.description,
+            '',
+            '**Spec**:',
+            ticket.spec ?? '(none)',
+            '',
+            `## Outcome: ${outcome.success ? 'SUCCESS' : 'FAILED'}`,
+        ];
+        if (!outcome.success && outcome.error) {
+            parts.push('', '**Error**:', outcome.error.slice(0, 1000));
+        }
+        if (outcome.diffReviewIssues && outcome.diffReviewIssues.length > 0) {
+            parts.push('', '**Diff Review Issues**:', ...outcome.diffReviewIssues.map(i => `- ${i}`));
+        }
+        if (outcome.buildFailed) {
+            parts.push('', '**Build**: FAILED');
+        }
+        if (diff) {
+            const truncatedDiff = diff.length > 50_000 ? diff.slice(0, 50_000) + '\n...(truncated)' : diff;
+            parts.push('', '## Diff', '```diff', truncatedDiff, '```');
+        }
+        else {
+            parts.push('', '## Diff', 'No diff available (agent may have failed before committing).');
+        }
+        if (existingLearnings) {
+            parts.push('', '## Existing Learnings (do not repeat these)', existingLearnings);
+        }
+        const prompt = parts.join('\n');
+        const messages = query({
+            prompt,
+            options: {
+                model: CONFIG.DIFF_REVIEW_MODEL, // Reuse Haiku config
+                cwd: projectDir,
+                tools: ['Read', 'Glob', 'Grep'],
+                allowedTools: ['Read', 'Glob', 'Grep'],
+                maxTurns: 5,
+                maxBudgetUsd: 0.25,
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                settingSources: ['project'],
+                systemPrompt: { type: 'preset', preset: 'claude_code' },
+                stderr: () => { },
+            },
+        });
+        let output = '';
+        for await (const message of messages) {
+            if (message.type === 'assistant') {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text')
+                            output = block.text;
+                    }
+                }
+                else if (typeof content === 'string') {
+                    output = content;
+                }
+            }
+            if (message.type === 'result') {
+                if ('result' in message && message.result) {
+                    output = message.result;
+                }
+            }
+        }
+        // Only save if the retro produced something meaningful
+        const trimmed = output.trim();
+        if (trimmed && !trimmed.toLowerCase().includes('no new learnings')) {
+            const header = outcome.success
+                ? `**Retro (success): ${ticket.title}**`
+                : `**Retro (failed): ${ticket.title}**`;
+            appendLearning(projectDir, `${header}\n${trimmed}`);
+            log(DIM, 'RETRO', `Saved ${trimmed.split('\n').filter(l => l.startsWith('-') || l.startsWith('*')).length} learnings`);
+        }
+        else {
+            log(DIM, 'RETRO', 'No new learnings');
+        }
+    }
+    catch (e) {
+        // Retro is best-effort — never block the pipeline
+        log(DIM, 'RETRO', `Skipped: ${e instanceof Error ? e.message : e}`);
+    }
+}
 async function runExecuteAgent(ticket) {
     const projectDir = getProjectDir(ticket.project);
     if (!projectDir) {
@@ -303,6 +406,7 @@ async function runExecuteAgent(ticket) {
     createWorktree(projectDir, branchName, worktreeDir, baseBranch);
     let cost = 0;
     let commitCount = 0;
+    let retroOutcome = { success: false };
     try {
         const promptParts = [
             executePrompt,
@@ -402,6 +506,7 @@ async function runExecuteAgent(ticket) {
         const diffReview = await runDiffReviewAgent(worktreeDir, baseBranch, ticket.spec ?? '', ticket.description, []);
         cost += diffReview.cost;
         if (!diffReview.result.approved) {
+            retroOutcome = { success: false, error: 'Diff review rejected the changes', diffReviewIssues: diffReview.result.issues };
             throw new Error(`Diff review failed:\n${diffReview.result.issues.map(i => `  - ${i}`).join('\n')}`);
         }
         log(GREEN, 'REVIEW', `Diff review passed: ${diffReview.result.summary}`);
@@ -484,11 +589,7 @@ async function runExecuteAgent(ticket) {
             `Cost: $${cost.toFixed(2)} | Duration: ${duration}s`,
         ].join('\n');
         await addComment(ticket.id, comment);
-        appendLearning(projectDir, [
-            `**Execute: ${ticket.title}**`,
-            `Branch: ${branchName}, Commits: ${commitCount}`,
-            `Cost: $${cost.toFixed(2)}`,
-        ].join('\n'));
+        retroOutcome = { success: true };
         log(GREEN, 'EXECUTE', `Done: branch=${branchName} cost=$${cost.toFixed(2)}${prUrl ? ` pr=${prUrl}` : ''}`);
     }
     catch (error) {
@@ -502,13 +603,17 @@ async function runExecuteAgent(ticket) {
             `Cost: $${cost.toFixed(2)} | Duration: ${duration}s`,
         ].join('\n');
         await addComment(ticket.id, comment);
-        appendLearning(projectDir, [
-            `**Failed execute: ${ticket.title}**`,
-            `Error: ${errMsg.slice(0, 200)}`,
-        ].join('\n'));
+        retroOutcome = {
+            success: false,
+            error: errMsg,
+            buildFailed: errMsg.includes('Build validation failed'),
+        };
         throw error;
     }
     finally {
+        // Run retro before cleaning up worktree (so it can read the diff)
+        log(DIM, 'RETRO', 'Running post-execution retrospective...');
+        await runRetroAgent(projectDir, worktreeDir, baseBranch, ticket, retroOutcome);
         // Always clean up the worktree
         removeWorktree(projectDir, worktreeDir);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticket-to-pr",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Drag a Notion ticket, get a pull request. AI-powered dev automation.",
   "type": "module",
   "bin": {

package/prompts/retro.md

@@ -0,0 +1,27 @@
+You are conducting a retrospective on an AI agent's work on a codebase.
+
+## Your Task
+Analyze what happened during this ticket execution and extract lessons that will help future agent runs on this same project. You are writing notes for a future AI agent, not a human.
+
+## What to Look For
+
+### On Success
+- **Conventions discovered**: file naming, import patterns, export style, component structure, API response shapes, error handling patterns
+- **What worked**: approaches or patterns that led to clean implementation
+- **Codebase quirks**: path aliases, custom configs, non-obvious setup requirements, framework-specific patterns
+
+### On Failure
+- **Root cause**: what specifically went wrong and why (not just the error message)
+- **What to do differently**: concrete, actionable advice for next time
+- **Codebase constraints**: things the agent didn't know about that caused the failure
+
+### Always
+- **Capability assessment**: what types of changes are easy/hard in this project
+- **Suggestions**: improvements to the project's CLAUDE.md or configuration that would help future runs
+
+## Output Rules
+- Write 2-5 bullet points. Each must be a specific, actionable lesson.
+- Start each bullet with a category tag: `[convention]`, `[mistake]`, `[capability]`, or `[suggestion]`
+- Be specific to THIS project. "Use TypeScript" is useless. "This project uses strict TypeScript with no implicit any — always add explicit return types on exported functions" is useful.
+- Don't repeat lessons that already exist in the project learnings.
+- If nothing useful was learned (e.g., trivial change, obvious outcome), just write: `No new learnings.`