feat: Make generate-implementation actually implement code instead of just creating plans

htilly · htilly · commit 141016f3cca1 · 2026-01-27T22:49:42.000+01:00
- Updated generate-implementation.mjs to generate and apply actual code diffs
- Uses git apply or patch command to apply changes
- Falls back to implementation plan if code application fails
- Updated workflow to handle both code changes and fallback plans
- PRs now contain actual code implementations when successful
diff --git a/.github/agent/generate-implementation.mjs b/.github/agent/generate-implementation.mjs
@@ -2,16 +2,17 @@ import Anthropic from "@anthropic-ai/sdk";
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
+import { execSync } from "child_process";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 /**
- * Generate Implementation - Use Claude to analyze codebase and generate implementation
+ * Generate Implementation - Use Claude to analyze codebase and IMPLEMENT code changes
  *
  * This script uses Claude to:
  * 1. Analyze the existing codebase
- * 2. Generate an implementation plan
- * 3. Create code changes for the feature request
+ * 2. Generate actual code changes (diffs)
+ * 3. Apply the changes to the codebase
  */
 
 const enhancedTask = process.env.ENHANCED_TASK || process.env.TASK || "";
@@ -54,21 +55,22 @@ function getProjectContext() {
     const indexJs = readFileSync(resolve(repoRoot, "index.js"), "utf8");
     files.push({
       path: "index.js",
-      content: indexJs.substring(0, 5000) // First 5000 chars to avoid token limits
+      content: indexJs.substring(0, 10000) // More context for main file
     });
   } catch (e) {
     console.warn("[IMPLEMENTATION] Could not read index.js");
   }
 
-  // Read lib directory structure
+  // Read lib directory files
   try {
     const libFiles = [
       "lib/slack.js",
       "lib/discord.js",
       "lib/voting.js",
       "lib/command-handlers.js",
       "lib/ai-handler.js",
-      "lib/spotify.js"
+      "lib/spotify.js",
+      "lib/add-handlers.js"
     ];
 
     for (const libFile of libFiles) {
@@ -77,7 +79,7 @@ function getProjectContext() {
         const content = readFileSync(fullPath, "utf8");
         files.push({
           path: libFile,
-          content: content.substring(0, 3000) // First 3000 chars per file
+          content: content.substring(0, 5000) // More context per file
         });
       }
     }
@@ -89,11 +91,57 @@ function getProjectContext() {
 }
 
 /**
- * Generate implementation using Claude
+ * Apply diff to files
+ */
+function applyDiff(diff) {
+  const repoRoot = resolve(__dirname, "../..");
+  const tempPatchFile = resolve(repoRoot, `.tmp-patch-${issueNumber}.patch`);
+  
+  try {
+    // Write diff to temporary patch file
+    writeFileSync(tempPatchFile, diff, "utf8");
+    console.log(`[IMPLEMENTATION] Wrote patch to ${tempPatchFile}`);
+    
+    // Try to apply the patch
+    try {
+      execSync(`cd "${repoRoot}" && git apply --ignore-whitespace "${tempPatchFile}"`, {
+        stdio: 'inherit'
+      });
+      console.log(`[IMPLEMENTATION] ✅ Successfully applied patch`);
+      return true;
+    } catch (applyError) {
+      console.warn(`[IMPLEMENTATION] ⚠️  git apply failed, trying patch command...`);
+      try {
+        execSync(`cd "${repoRoot}" && patch -p1 < "${tempPatchFile}"`, {
+          stdio: 'inherit'
+        });
+        console.log(`[IMPLEMENTATION] ✅ Successfully applied patch with patch command`);
+        return true;
+      } catch (patchError) {
+        console.error(`[IMPLEMENTATION] ❌ Failed to apply patch`);
+        console.error(`[IMPLEMENTATION] git apply error: ${applyError.message}`);
+        console.error(`[IMPLEMENTATION] patch error: ${patchError.message}`);
+        return false;
+      }
+    }
+  } finally {
+    // Clean up temp file
+    try {
+      if (existsSync(tempPatchFile)) {
+        execSync(`rm "${tempPatchFile}"`);
+      }
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Generate and apply implementation using Claude
  */
 async function generateImplementation() {
   try {
-    console.log(`[IMPLEMENTATION] Generating implementation with ${model}...`);
+    console.log(`[IMPLEMENTATION] Generating code implementation with ${model}...`);
     console.log(`[IMPLEMENTATION] Feature request: ${enhancedTask}`);
 
     const projectFiles = getProjectContext();
@@ -108,7 +156,7 @@ async function generateImplementation() {
 
 The project is called SlackONOS and is a democratic bot where users can vote on songs to play.
 
-Your task is to analyze the feature request and generate a concrete implementation plan with code suggestions.
+Your task is to IMPLEMENT the feature request by generating actual code changes in unified diff format.
 
 Project context:
 - Node.js application
@@ -118,29 +166,35 @@ Project context:
 - Uses AI for natural language commands
 - Supports Spotify integration
 
-Output format:
-1. **Implementation Plan** - Brief overview of what needs to be changed
-2. **Files to Modify/Create** - List specific files
-3. **Code Changes** - Provide actual code snippets or full file contents
+CRITICAL: You must generate a VALID unified diff that can be applied with git apply or patch command.
+
+DIFF FORMAT REQUIREMENTS:
+1. Start each file with "--- a/path/to/file.js" and "+++ b/path/to/file.js" (BOTH lines required)
+2. NO "diff --git" line, NO "index" line with hashes
+3. Include "@@ -startLine,numLines +startLine,numLines @@" hunk headers
+4. Include at least 3 lines of context before and after each change
+5. Use "+" prefix for additions, "-" prefix for removals, " " (space) prefix for context
+6. Ensure line numbers match actual file contents
+7. Output ONLY the diff - no explanations, no markdown code blocks, no text before/after
+8. The diff MUST be complete and valid - every file section must have BOTH "--- a/path" AND "+++ b/path" lines
+9. NEVER truncate file paths - always write complete paths
+10. If creating new files, use "--- /dev/null" and "+++ b/path/to/newfile.js"
 
-Be specific and actionable. Focus on the actual code changes needed.`;
+Generate the complete, valid unified diff now.`;
 
     const userPrompt = `Feature Request to Implement:
 
 ${enhancedTask}
 
 ${contextText}
 
-Please provide:
-1. A brief implementation plan
-2. List of files to modify or create
-3. Actual code changes with clear instructions
+Generate a valid unified diff that implements this feature. The diff must be complete and ready to apply with git apply or patch command.
 
-Make it actionable and ready to commit.`;
+Output ONLY the diff, no explanations.`;
 
     const response = await anthropic.messages.create({
       model: model,
-      max_tokens: 4096,
+      max_tokens: 8192, // Increased for larger diffs
       messages: [
         {
           role: "user",
@@ -154,23 +208,66 @@ Make it actionable and ready to commit.`;
       ]
     });
 
-    const implementation = response.content[0].text;
+    const diff = response.content[0].text;
 
-    console.log(`[IMPLEMENTATION] Generated implementation plan:`);
-    console.log(implementation);
+    console.log(`[IMPLEMENTATION] Generated diff:`);
+    console.log(diff);
 
-    // Save implementation to file for the workflow to use
-    const outputPath = resolve(__dirname, `../../implementation-${issueNumber}.md`);
-    writeFileSync(outputPath, implementation, "utf8");
-    console.log(`[IMPLEMENTATION] Saved to ${outputPath}`);
+    // Extract diff from potential markdown code blocks
+    let cleanDiff = diff.trim();
+    if (cleanDiff.includes('```')) {
+      const matches = cleanDiff.matchAll(/```(?:diff)?\n([\s\S]*?)```/g);
+      const extracted = [];
+      for (const match of matches) {
+        extracted.push(match[1].trim());
+      }
+      if (extracted.length > 0) {
+        cleanDiff = extracted.reduce((a, b) => a.length > b.length ? a : b);
+      }
+    }
 
-    // Output markers for workflow parsing
-    console.log(`\nIMPLEMENTATION_FILE:${outputPath}`);
-    console.log(`IMPLEMENTATION_START`);
-    console.log(implementation);
-    console.log(`IMPLEMENTATION_END`);
+    // Validate diff format
+    if (!cleanDiff.includes('--- a/') || !cleanDiff.includes('+++ b/')) {
+      console.error(`[IMPLEMENTATION] ❌ Generated output is not a valid diff format`);
+      console.error(`[IMPLEMENTATION] Missing required diff markers (--- a/ or +++ b/)`);
+      
+      // Save as fallback implementation plan
+      const outputPath = resolve(__dirname, `../../implementation-${issueNumber}.md`);
+      writeFileSync(outputPath, `# Implementation Plan\n\n${enhancedTask}\n\n## Generated Output\n\n${diff}`, "utf8");
+      console.log(`[IMPLEMENTATION] Saved as fallback plan to ${outputPath}`);
+      console.log(`\nIMPLEMENTATION_FILE:${outputPath}`);
+      return;
+    }
 
-    return implementation;
+    // Apply the diff
+    const applied = applyDiff(cleanDiff);
+    
+    if (applied) {
+      console.log(`[IMPLEMENTATION] ✅ Code changes successfully applied!`);
+      
+      // List changed files
+      try {
+        const changedFiles = execSync('git diff --name-only', { encoding: 'utf8' }).trim().split('\n').filter(f => f);
+        console.log(`[IMPLEMENTATION] Changed files:`);
+        changedFiles.forEach(f => console.log(`[IMPLEMENTATION]   - ${f}`));
+        
+        // Output marker for workflow
+        console.log(`\nIMPLEMENTATION_FILE:APPLIED`);
+        console.log(`IMPLEMENTATION_CHANGED_FILES:${changedFiles.join(',')}`);
+      } catch (e) {
+        console.warn(`[IMPLEMENTATION] Could not list changed files: ${e.message}`);
+        console.log(`\nIMPLEMENTATION_FILE:APPLIED`);
+      }
+    } else {
+      console.error(`[IMPLEMENTATION] ❌ Failed to apply code changes`);
+      
+      // Save diff as fallback
+      const outputPath = resolve(__dirname, `../../implementation-${issueNumber}.patch`);
+      writeFileSync(outputPath, cleanDiff, "utf8");
+      console.log(`[IMPLEMENTATION] Saved diff to ${outputPath} for manual review`);
+      console.log(`\nIMPLEMENTATION_FILE:${outputPath}`);
+      process.exit(1);
+    }
 
   } catch (error) {
     console.error(`[IMPLEMENTATION] Error generating implementation: ${error.message}`);
diff --git a/.github/workflows/feature-request-enhance.yml b/.github/workflows/feature-request-enhance.yml
@@ -348,7 +348,7 @@ jobs:
             } >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Generate implementation with Claude
+      - name: Generate and apply implementation with Claude
         id: generate
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -361,14 +361,23 @@ jobs:
           OUTPUT=$(node .github/agent/generate-implementation.mjs 2>&1)
           echo "$OUTPUT"
 
-          # Extract implementation file path
-          IMPL_FILE=$(echo "$OUTPUT" | grep "IMPLEMENTATION_FILE:" | sed 's/IMPLEMENTATION_FILE://' | tr -d '[:space:]')
-          echo "implementation_file=$IMPL_FILE" >> $GITHUB_OUTPUT
+          # Check if code was applied or if we have a fallback file
+          if echo "$OUTPUT" | grep -q "IMPLEMENTATION_FILE:APPLIED"; then
+            echo "code_applied=true" >> $GITHUB_OUTPUT
+            CHANGED_FILES=$(echo "$OUTPUT" | grep "IMPLEMENTATION_CHANGED_FILES:" | sed 's/IMPLEMENTATION_CHANGED_FILES://' | tr -d '[:space:]')
+            echo "changed_files=$CHANGED_FILES" >> $GITHUB_OUTPUT
+          else
+            echo "code_applied=false" >> $GITHUB_OUTPUT
+            IMPL_FILE=$(echo "$OUTPUT" | grep "IMPLEMENTATION_FILE:" | sed 's/IMPLEMENTATION_FILE://' | tr -d '[:space:]')
+            echo "implementation_file=$IMPL_FILE" >> $GITHUB_OUTPUT
+          fi
 
       - name: Create implementation branch and PR
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ISSUE_NUMBER: ${{ needs.check-label.outputs.issue_number }}
+          CODE_APPLIED: ${{ steps.generate.outputs.code_applied }}
+          CHANGED_FILES: ${{ steps.generate.outputs.changed_files }}
           IMPL_FILE: ${{ steps.generate.outputs.implementation_file }}
         run: |
           set -e
@@ -381,38 +390,83 @@ jobs:
           BRANCH_NAME="feature/issue-$ISSUE_NUMBER-implementation"
           git checkout -b "$BRANCH_NAME"
 
-          # Add the implementation file
-          if [ -f "$IMPL_FILE" ]; then
+          # Check if code was applied or if we need to add fallback file
+          if [ "$CODE_APPLIED" = "true" ]; then
+            # Code was applied - add all changed files
+            echo "✅ Code changes were applied, staging all changes..."
+            git add -A
+            
+            # Get list of changed files for commit message
+            CHANGED=$(git diff --cached --name-only | tr '\n' ',' | sed 's/,$//')
+            echo "Changed files: $CHANGED"
+            
+            # Create commit message
+            COMMIT_MSG=$(cat <<EOF
+          Implement feature request for issue #$ISSUE_NUMBER
+
+          This is an AI-generated implementation created by Claude.
+          Please review and test the changes.
+
+          Changed files: $CHANGED
+          Related issue: #$ISSUE_NUMBER
+          EOF
+            )
+          elif [ -f "$IMPL_FILE" ]; then
+            # Fallback: add the implementation plan file
+            echo "⚠️  Code application failed, adding implementation plan file..."
             git add "$IMPL_FILE"
-
-            # Create commit with heredoc to handle multiline
-            git commit -m "$(cat <<EOF
+            CHANGED="$IMPL_FILE"
+            
+            # Create commit message
+            COMMIT_MSG=$(cat <<EOF
           Add implementation plan for issue #$ISSUE_NUMBER
 
           This is an AI-generated implementation plan created by Claude.
-          Please review and adapt as needed.
+          Code application failed - please review the plan and implement manually.
 
           Related issue: #$ISSUE_NUMBER
           EOF
-          )"
+            )
+          else
+            echo "❌ No code changes and no implementation file found"
+            exit 1
+          fi
+          
+          git commit -m "$COMMIT_MSG"
+
+          # Push branch
+          git push -u origin "$BRANCH_NAME"
+
+          # Create PR body
+          if [ "$CODE_APPLIED" = "true" ]; then
+            PR_BODY=$(cat <<EOF
+          ## 🤖 AI-Generated Implementation
+
+          This PR contains an **actual code implementation** generated by Claude AI for issue #$ISSUE_NUMBER.
 
-            # Push branch
-            git push -u origin "$BRANCH_NAME"
+          ### ✅ Changes Applied
+          The following files were modified:
+          $(echo "$CHANGED_FILES" | tr ',' '\n' | sed 's/^/          - /')
 
-            # Create PR body using heredoc
-            PR_BODY=$(cat <<'EOF'
+          ### 📝 Review Notes
+          Please review the changes and run tests before merging.
+          EOF
+            )
+          else
+            PR_BODY=$(cat <<EOF
           ## 🤖 AI-Generated Implementation Plan
 
           This PR contains an implementation plan generated by Claude AI for issue #$ISSUE_NUMBER.
 
+          ⚠️ **Note**: Code application failed. This PR contains a plan that needs manual implementation.
+
           ### 📋 Implementation Plan
           See [implementation-$ISSUE_NUMBER.md](./implementation-$ISSUE_NUMBER.md) for details.
 
           ### ⚠️ Important
-          This is an **AI-generated proposal**. Please:
-          - Review the implementation plan carefully
-          - Adapt and modify as needed
-          - Add actual code changes based on the plan
+          This is an **AI-generated implementation plan**. Please:
+          - Review the plan carefully
+          - Implement the code changes manually
           - Test thoroughly before merging
 
           Closes #$ISSUE_NUMBER
