jfl 0.4.2 → 0.4.3

package/template/.github/workflows/jfl-review.yml

@@ -0,0 +1,371 @@
+name: JFL AI Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    branches: [main]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  review:
+    name: AI Code Review
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    if: startsWith(github.head_ref, 'pp/') || contains(github.event.pull_request.labels.*.name, 'ai-review')
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Gather project context
+        id: context
+        run: |
+          # Read project config
+          PROJECT_NAME=$(node -e "
+            try { console.log(JSON.parse(require('fs').readFileSync('.jfl/config.json','utf8')).name || 'unknown'); }
+            catch(e) { console.log('unknown'); }
+          ")
+          PROJECT_DESC=$(node -e "
+            try { console.log(JSON.parse(require('fs').readFileSync('.jfl/config.json','utf8')).description || ''); }
+            catch(e) { console.log(''); }
+          ")
+          echo "project_name=$PROJECT_NAME" >> $GITHUB_OUTPUT
+
+          # Build project context from repo files
+          node -e "
+            const fs = require('fs');
+            const sections = [];
+
+            // Project identity
+            sections.push('# Project: ' + '$PROJECT_NAME');
+            if ('$PROJECT_DESC') sections.push('$PROJECT_DESC');
+            sections.push('');
+
+            // Architecture (tech stack, structure, patterns)
+            try {
+              const arch = fs.readFileSync('knowledge/ARCHITECTURE.md', 'utf8');
+              // Extract first 2000 chars (tech stack + structure)
+              sections.push('## Architecture');
+              sections.push(arch.substring(0, 2000));
+              sections.push('');
+            } catch(e) {}
+
+            // Service spec (what the project does)
+            try {
+              const spec = fs.readFileSync('knowledge/SERVICE_SPEC.md', 'utf8');
+              sections.push('## Service Spec');
+              sections.push(spec.substring(0, 1000));
+              sections.push('');
+            } catch(e) {}
+
+            // Recent journal entries (last 5 for active context)
+            try {
+              const { execSync } = require('child_process');
+              const journal = execSync('cat .jfl/journal/*.jsonl 2>/dev/null | tail -5', { encoding: 'utf8' });
+              if (journal.trim()) {
+                sections.push('## Recent Activity');
+                sections.push(journal.trim());
+                sections.push('');
+              }
+            } catch(e) {}
+
+            // Recent decisions
+            try {
+              const { execSync } = require('child_process');
+              const decisions = execSync('cat .jfl/journal/*.jsonl 2>/dev/null | grep decision | tail -3', { encoding: 'utf8' });
+              if (decisions.trim()) {
+                sections.push('## Recent Decisions');
+                sections.push(decisions.trim());
+                sections.push('');
+              }
+            } catch(e) {}
+
+            const context = sections.join('\n');
+            fs.writeFileSync('/tmp/project-context.txt', context);
+            console.log('Context size: ' + context.length + ' chars');
+          "
+
+      - name: Get PR diff and review
+        id: review
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_BODY: ${{ github.event.pull_request.body }}
+        run: |
+          # Get full diff
+          git diff origin/main...HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx' | head -4000 > /tmp/diff.txt
+          git diff origin/main...HEAD --stat > /tmp/stats.txt
+          git diff origin/main...HEAD --name-only -- '*.ts' '*.tsx' '*.js' '*.jsx' > /tmp/files.txt
+
+          DIFF_SIZE=$(wc -c < /tmp/diff.txt | tr -d ' ')
+          echo "Diff size: $DIFF_SIZE bytes"
+
+          if [ "$DIFF_SIZE" -lt 10 ]; then
+            echo "No code diff to review" > /tmp/review.md
+            echo '{"findings":[]}' > /tmp/findings.json
+            echo "has_review=true" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Build context-aware payload
+          node -e "
+            const fs = require('fs');
+            const diff = fs.readFileSync('/tmp/diff.txt', 'utf8').substring(0, 12000);
+            const context = fs.readFileSync('/tmp/project-context.txt', 'utf8').substring(0, 3000);
+            const title = process.env.PR_TITLE || '';
+            const body = (process.env.PR_BODY || '').substring(0, 500);
+
+            const systemPrompt = [
+              'You are a senior code reviewer with full project context.',
+              '',
+              '--- PROJECT CONTEXT ---',
+              context,
+              '--- END CONTEXT ---',
+              '',
+              'Review this PR diff with awareness of the project\\'s architecture, patterns, and conventions.',
+              '',
+              'Review for:',
+              '1. Bugs - Logic errors, null/undefined risks, race conditions',
+              '2. Security - Injection, XSS, credential exposure, unsafe operations',
+              '3. Architecture - Does this follow the project\\'s established patterns?',
+              '4. Performance - N+1 queries, unnecessary re-renders, memory leaks',
+              '5. Test gaps - What should be tested that is not',
+              '',
+              'Be concise. Only flag real issues, not style preferences. If the code is clean, say so briefly.',
+              'Use your knowledge of the project to distinguish intentional patterns from mistakes.',
+              '',
+              'Output format:',
+              '## Findings',
+              '- [severity_emoji] file:line - description',
+              '',
+              'Severity: red_circle (bug/security), yellow_circle (perf/architecture concern), blue_circle (suggestion)',
+              '',
+              'If no issues: ## Findings\\nNo issues found. Code looks clean.',
+              '',
+              'After the markdown findings, output a JSON block on a new line starting with FINDINGS_JSON:',
+              'FINDINGS_JSON:[{\"severity\":\"red|yellow|blue\",\"file\":\"path\",\"line\":0,\"description\":\"...\"}]',
+              'Output an empty array [] if no findings.',
+            ].join('\\n');
+
+            const payload = {
+              model: 'gpt-4o-mini',
+              messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: 'PR: ' + title + '\\n' + (body ? 'Description: ' + body + '\\n\\n' : '\\n') + diff }
+              ],
+              max_tokens: 1500,
+              temperature: 0.1
+            };
+
+            fs.writeFileSync('/tmp/payload.json', JSON.stringify(payload));
+          "
+
+          # Try OpenAI
+          REVIEW=""
+          if [ -n "$OPENAI_API_KEY" ]; then
+            RESPONSE=$(curl -s -X POST https://api.openai.com/v1/chat/completions \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer $OPENAI_API_KEY" \
+              -d @/tmp/payload.json 2>/dev/null)
+            REVIEW=$(echo "$RESPONSE" | node -e "
+              let d=''; process.stdin.on('data',c=>d+=c); process.stdin.on('end',()=>{
+                try { console.log(JSON.parse(d).choices[0].message.content); }
+                catch(e) { console.log(''); }
+              })
+            ")
+          fi
+
+          # Fallback to OpenRouter
+          if [ -z "$REVIEW" ] && [ -n "$OPENROUTER_API_KEY" ]; then
+            echo "OpenAI failed, trying OpenRouter..."
+            node -e "
+              const fs = require('fs');
+              const p = JSON.parse(fs.readFileSync('/tmp/payload.json', 'utf8'));
+              p.model = 'anthropic/claude-sonnet-4';
+              fs.writeFileSync('/tmp/payload-or.json', JSON.stringify(p));
+            "
+            RESPONSE=$(curl -s -X POST https://openrouter.ai/api/v1/chat/completions \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer $OPENROUTER_API_KEY" \
+              -d @/tmp/payload-or.json 2>/dev/null)
+            REVIEW=$(echo "$RESPONSE" | node -e "
+              let d=''; process.stdin.on('data',c=>d+=c); process.stdin.on('end',()=>{
+                try { console.log(JSON.parse(d).choices[0].message.content); }
+                catch(e) { console.log(''); }
+              })
+            ")
+          fi
+
+          if [ -z "$REVIEW" ]; then
+            REVIEW="AI review unavailable — both OpenAI and OpenRouter failed."
+            echo '{"findings":[]}' > /tmp/findings.json
+          fi
+
+          echo "$REVIEW" > /tmp/review.md
+          echo "has_review=true" >> $GITHUB_OUTPUT
+
+      - name: Extract structured findings
+        id: findings
+        if: steps.review.outputs.has_review == 'true'
+        run: |
+          # Parse FINDINGS_JSON from review output
+          node -e "
+            const fs = require('fs');
+            const review = fs.readFileSync('/tmp/review.md', 'utf8');
+
+            // Extract FINDINGS_JSON line
+            const match = review.match(/FINDINGS_JSON:\s*(\[.*\])/);
+            let findings = [];
+            if (match) {
+              try { findings = JSON.parse(match[1]); } catch(e) {}
+            }
+
+            // Also count by severity from markdown as fallback
+            const redCount = (review.match(/🔴/g) || []).length;
+            const yellowCount = (review.match(/🟡/g) || []).length;
+            const blueCount = (review.match(/🔵/g) || []).length;
+
+            const result = {
+              findings: findings,
+              counts: { red: redCount, yellow: yellowCount, blue: blueCount },
+              total: findings.length || (redCount + yellowCount + blueCount),
+              has_blockers: findings.some(f => f.severity === 'red') || redCount > 0
+            };
+
+            fs.writeFileSync('/tmp/findings.json', JSON.stringify(result));
+
+            // Clean the FINDINGS_JSON line from the review markdown
+            const cleanReview = review.replace(/FINDINGS_JSON:.*$/m, '').trim();
+            fs.writeFileSync('/tmp/review.md', cleanReview);
+
+            // Set step outputs for downstream steps
+            const outputFile = process.env.GITHUB_OUTPUT;
+            if (outputFile) {
+              fs.appendFileSync(outputFile, 'has_blockers=' + result.has_blockers + '\n');
+              fs.appendFileSync(outputFile, 'red_count=' + result.counts.red + '\n');
+              fs.appendFileSync(outputFile, 'yellow_count=' + result.counts.yellow + '\n');
+              fs.appendFileSync(outputFile, 'blue_count=' + result.counts.blue + '\n');
+              fs.appendFileSync(outputFile, 'total=' + result.total + '\n');
+            }
+
+            console.log('Findings: ' + result.total + ' (red=' + result.counts.red + ' yellow=' + result.counts.yellow + ' blue=' + result.counts.blue + ')');
+          "
+
+      - name: Comment on PR
+        if: steps.review.outputs.has_review == 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const review = fs.readFileSync('/tmp/review.md', 'utf8');
+            const stats = fs.readFileSync('/tmp/stats.txt', 'utf8');
+            const findings = JSON.parse(fs.readFileSync('/tmp/findings.json', 'utf8'));
+            const projectName = '${{ steps.context.outputs.project_name }}';
+            const marker = '<!-- jfl-ai-review -->';
+
+            const body = [
+              marker,
+              `## AI Code Review — ${projectName}`,
+              '',
+              review,
+              '',
+              '---',
+              '<details><summary>Diff stats</summary>',
+              '',
+              '```',
+              stats,
+              '```',
+              '</details>',
+              '',
+              findings.has_blockers
+                ? ':warning: **Blockers found** — address red findings before merge'
+                : (findings.total > 0
+                  ? ':white_check_mark: No blockers — suggestions only'
+                  : ':white_check_mark: Clean'),
+              '',
+              `*Reviewed by JFL AI Review (context-aware) | ${findings.total} finding(s)*`
+            ].join('\n');
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            const existing = comments.find(c => c.body.includes(marker));
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: existing.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body,
+              });
+            }
+
+      - name: Block or approve based on findings
+        if: always()
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if [ "${{ steps.findings.outputs.has_blockers }}" = "true" ]; then
+            echo "Red findings detected — requesting changes"
+            gh pr review ${{ github.event.pull_request.number }} --request-changes \
+              --body "JFL AI Review: ${{ steps.findings.outputs.red_count }} blocker(s) found. Address red findings before merge."
+          fi
+
+      - name: Post review:findings event to hub
+        if: always()
+        continue-on-error: true
+        env:
+          JFL_HUB_URL: ${{ secrets.JFL_HUB_URL }}
+          JFL_HUB_TOKEN: ${{ secrets.JFL_HUB_TOKEN }}
+        run: |
+          # Build structured event with findings
+          node -e "
+            const fs = require('fs');
+            let findings = { findings: [], counts: { red: 0, yellow: 0, blue: 0 }, total: 0, has_blockers: false };
+            try { findings = JSON.parse(fs.readFileSync('/tmp/findings.json', 'utf8')); } catch(e) {}
+
+            const event = {
+              type: 'review:findings',
+              source: 'github-action',
+              data: {
+                pr_number: ${{ github.event.pull_request.number }},
+                pr_url: '${{ github.event.pull_request.html_url }}',
+                branch: '${{ github.head_ref }}',
+                commit_sha: '${{ github.sha }}',
+                reviewer: 'ai',
+                model: 'gpt-4o-mini',
+                findings: findings.findings,
+                counts: findings.counts,
+                total_findings: findings.total,
+                has_blockers: findings.has_blockers,
+                run_url: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+              }
+            };
+
+            fs.writeFileSync('/tmp/review-event.json', JSON.stringify(event));
+          "
+
+          if [ -n "$JFL_HUB_URL" ]; then
+            curl -s -X POST "$JFL_HUB_URL/api/events" \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer $JFL_HUB_TOKEN" \
+              -d @/tmp/review-event.json || echo "Hub not available"
+          fi

package/template/.jfl/{flows-self-driving.yaml → flows/self-driving.yaml}

@@ -66,6 +66,26 @@ flows:
       - type: log
         message: "Training tuple logged: state={{data.baseline}} action=PR#{{data.pr_number}} reward={{data.delta}}"
 
+  # Proactive experiment trigger — PP picks its own next task
+  - name: proactive-experiment
+    description: "Pick and execute the highest-value experiment from trajectory history"
+    enabled: true
+    trigger:
+      pattern: "cron:daily"
+    gate:
+      requires_approval: true
+    actions:
+      - type: log
+        message: "Proactive experiment trigger: evaluating next best action"
+      - type: spawn
+        command: jfl
+        args: ["peter", "experiment"]
+        detach: true
+      - type: journal
+        entry_type: "milestone"
+        title: "Proactive experiment dispatched"
+        summary: "Autonomous experiment selection triggered. PP will analyze trajectory history and propose next improvement."
+
   # Review → Fix loop flows
   - name: block-merge-on-blockers
     description: "Request changes when AI review finds red (blocker) findings"