@benzotti/jedi 0.1.34 → 0.1.36

package/README.md

@@ -1,13 +1,6 @@
-```
-     ██╗███████╗██████╗ ██╗
-     ██║██╔════╝██╔══██╗██║
-     ██║█████╗  ██║  ██║██║
-██   ██║██╔══╝  ██║  ██║██║
-╚█████╔╝███████╗██████╔╝██║
- ╚════╝ ╚══════╝╚═════╝ ╚═╝
-```
+# Jedi
 
-**Context-efficient AI development framework for Claude Code.**
+**Multi-agent development framework for Claude Code — plan, implement, review, and ship with specialist agents and minimal token overhead.**
 
 [![npm version](https://img.shields.io/npm/v/@benzotti/jedi)](https://www.npmjs.com/package/@benzotti/jedi) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 

package/action/workflow-template.yml

@@ -7,6 +7,9 @@
 #
 # Optional:
 #   - Set CLICKUP_API_TOKEN secret for ClickUp ticket integration
+#   - Set JEDI_COMMIT_LEARNINGS=true repo variable to persist learnings in git
+#   - Set JEDI_LEARNINGS_REPO variable to push learnings to a central repo (e.g. org/jedi-learnings)
+#   - Set JEDI_LEARNINGS_TOKEN secret (PAT with repo access) when using an external learnings repo
 #   - Run `npx @benzotti/jedi init` locally to customise framework files
 #
 # Usage: Comment on any issue or PR with "Hey Jedi" followed by a command:
@@ -21,7 +24,8 @@
 # reply with feedback to refine, or say "approved" to finalise.
 #
 # Learnings: Jedi accumulates team preferences across PRs automatically.
-# No files to commit — everything lives in the GitHub Actions cache.
+# By default learnings live in the GitHub Actions cache. Set JEDI_COMMIT_LEARNINGS=true
+# to persist them in git (recommended — cache entries expire after 7 days of inactivity).
 
 name: Jedi
 
@@ -117,6 +121,49 @@ jobs:
             grep -qxF "$pattern" .git/info/exclude 2>/dev/null || echo "$pattern" >> .git/info/exclude
           done
 
+      # Fetch shared learnings from an external repo if configured.
+      # This merges cross-project learnings into the local framework before agents run.
+      - name: Fetch shared learnings
+        if: vars.JEDI_LEARNINGS_REPO != ''
+        run: |
+          LEARNINGS_DIR=".jdi/framework/learnings"
+          mkdir -p "$LEARNINGS_DIR"
+
+          # Clone only the directory for this repo's learnings (sparse checkout)
+          REPO_SUBDIR="${{ github.repository }}"
+          TMPDIR=$(mktemp -d)
+          git clone --depth 1 --filter=blob:none --sparse \
+            "https://x-access-token:${LEARNINGS_TOKEN}@github.com/${LEARNINGS_REPO}.git" \
+            "$TMPDIR" 2>/dev/null || {
+              echo "Could not clone learnings repo — continuing without shared learnings"
+              exit 0
+            }
+
+          cd "$TMPDIR"
+          git sparse-checkout set "$REPO_SUBDIR" 2>/dev/null || true
+          cd - > /dev/null
+
+          # Copy learnings from external repo into local framework
+          # External learnings serve as baseline; cache/local files take precedence
+          if [ -d "$TMPDIR/$REPO_SUBDIR" ]; then
+            for f in "$TMPDIR/$REPO_SUBDIR"/*.md; do
+              [ -f "$f" ] || continue
+              BASENAME=$(basename "$f")
+              # Only copy if local file doesn't exist (cache/committed files take precedence)
+              if [ ! -f "$LEARNINGS_DIR/$BASENAME" ]; then
+                cp "$f" "$LEARNINGS_DIR/$BASENAME"
+                echo "Loaded shared learning: $BASENAME"
+              fi
+            done
+          else
+            echo "No shared learnings found for ${{ github.repository }} — continuing"
+          fi
+
+          rm -rf "$TMPDIR"
+        env:
+          LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO }}
+          LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}
+
       # Configure git for Jedi commits (used when implementing changes on PR branches)
       - name: Configure git
         run: |
@@ -171,13 +218,49 @@ jobs:
           key: jedi-state-${{ github.repository }}-${{ steps.pr.outputs.branch || github.head_ref || github.ref_name }}-${{ github.run_id }}
 
   # ── Promote learnings to main baseline when PRs merge ──
+  # Only runs when Jedi was actually used on the merged PR
   promote-learnings:
     if: github.event_name == 'push'
     runs-on: ubuntu-latest
     steps:
+      - name: Check if Jedi was involved
+        id: check
+        run: |
+          # Find the PR associated with this merge commit
+          PR_NUMBER=$(gh api "repos/$REPO/commits/${{ github.sha }}/pulls" --jq '.[0].number // empty' 2>/dev/null || true)
+          if [ -z "$PR_NUMBER" ]; then
+            echo "No associated PR found — skipping"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          # Check if Jedi commented on this PR (comments from github-actions bot mentioning Jedi)
+          JEDI_ACTIVITY=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --paginate \
+            --jq '[.[] | select(.user.login == "github-actions[bot]" and (.body | test("jedi|Jedi|🤖")))] | length' 2>/dev/null || echo "0")
+
+          # Also check if jedi[bot] made any commits on the PR
+          JEDI_COMMITS=$(gh api "repos/$REPO/pulls/$PR_NUMBER/commits" --paginate \
+            --jq '[.[] | select(.commit.author.name == "jedi[bot]")] | length' 2>/dev/null || echo "0")
+
+          if [ "$JEDI_ACTIVITY" -gt 0 ] || [ "$JEDI_COMMITS" -gt 0 ]; then
+            BRANCH=$(gh api "repos/$REPO/pulls/$PR_NUMBER" --jq '.head.ref')
+            echo "Jedi was active on PR #$PR_NUMBER (comments: $JEDI_ACTIVITY, commits: $JEDI_COMMITS) — promoting learnings"
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+            echo "branch=$BRANCH" >> "$GITHUB_OUTPUT"
+            echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+          else
+            echo "No Jedi activity on PR #$PR_NUMBER — skipping"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          fi
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+
       - uses: actions/checkout@v4
+        if: steps.check.outputs.skip != 'true'
 
-      - name: Restore latest Jedi state
+      - name: Restore Jedi state from merged branch
+        if: steps.check.outputs.skip != 'true'
         id: restore
         uses: actions/cache@v4
         with:
@@ -189,10 +272,10 @@ jobs:
             .claude/
           key: jedi-state-${{ github.repository }}-main-promotion-${{ github.sha }}
           restore-keys: |
-            jedi-state-${{ github.repository }}-
+            jedi-state-${{ github.repository }}-${{ steps.check.outputs.branch }}-
 
       - name: Promote to main baseline
-        if: steps.restore.outputs.cache-hit != ''
+        if: steps.check.outputs.skip != 'true' && steps.restore.outputs.cache-hit != ''
         uses: actions/cache/save@v4
         with:
           path: |
@@ -202,3 +285,93 @@ jobs:
             .jdi/plans/
             .claude/
           key: jedi-state-${{ github.repository }}-main-${{ github.sha }}
+
+      # Opt-in: commit learnings so they survive cache eviction.
+      # Set repo variable JEDI_COMMIT_LEARNINGS=true to enable.
+      #
+      # Where learnings are committed:
+      #   - Same repo (default): .jdi/framework/learnings/ on main
+      #   - External repo: set JEDI_LEARNINGS_REPO (e.g. org/jedi-learnings)
+      #     and JEDI_LEARNINGS_TOKEN secret. Learnings are namespaced under
+      #     <owner>/<repo>/ in the external repo to support multiple projects.
+      - name: Commit learnings to repo
+        if: >-
+          steps.check.outputs.skip != 'true'
+          && steps.restore.outputs.cache-hit != ''
+          && vars.JEDI_COMMIT_LEARNINGS == 'true'
+        run: |
+          LEARNINGS_SRC=".jdi/framework/learnings"
+
+          # Only proceed if there are learnings files with content
+          if [ ! -d "$LEARNINGS_SRC" ]; then
+            echo "No learnings directory found — skipping commit"
+            exit 0
+          fi
+
+          # Check if any learnings files have meaningful content (not just headers)
+          HAS_CONTENT=false
+          for f in "$LEARNINGS_SRC"/*.md; do
+            [ -f "$f" ] || continue
+            if grep -qvE '^\s*(#|<!--|$)' "$f" 2>/dev/null; then
+              HAS_CONTENT=true
+              break
+            fi
+          done
+
+          if [ "$HAS_CONTENT" != "true" ]; then
+            echo "No learnings content to commit — skipping"
+            exit 0
+          fi
+
+          git config user.name "jedi[bot]"
+          git config user.email "jedi[bot]@users.noreply.github.com"
+
+          if [ -n "$LEARNINGS_REPO" ]; then
+            # ── External repo: clone, copy learnings, push ──
+            REPO_SUBDIR="${{ github.repository }}"
+            TMPDIR=$(mktemp -d)
+
+            git clone --depth 1 \
+              "https://x-access-token:${LEARNINGS_TOKEN}@github.com/${LEARNINGS_REPO}.git" \
+              "$TMPDIR" 2>/dev/null || {
+                echo "::warning::Could not clone learnings repo ${LEARNINGS_REPO} — skipping commit"
+                exit 0
+              }
+
+            mkdir -p "$TMPDIR/$REPO_SUBDIR"
+            cp "$LEARNINGS_SRC"/*.md "$TMPDIR/$REPO_SUBDIR/"
+
+            cd "$TMPDIR"
+            git config user.name "jedi[bot]"
+            git config user.email "jedi[bot]@users.noreply.github.com"
+            git add "$REPO_SUBDIR"/*.md
+
+            if git diff --cached --quiet; then
+              echo "Learnings unchanged in external repo — nothing to commit"
+            else
+              git commit -m "chore(jedi): update learnings from ${{ github.repository }}
+
+          Source: PR #${{ steps.check.outputs.pr_number }} on ${{ github.repository }}
+          Learnings accumulated from PR reviews and feedback."
+              git push
+              echo "Learnings committed to ${LEARNINGS_REPO}/${REPO_SUBDIR}"
+            fi
+
+            cd - > /dev/null
+            rm -rf "$TMPDIR"
+          else
+            # ── Same repo: commit directly to main ──
+            git add "$LEARNINGS_SRC"/*.md
+            if git diff --cached --quiet; then
+              echo "Learnings unchanged — nothing to commit"
+            else
+              git commit -m "chore(jedi): update team learnings
+
+          Auto-committed by Jedi after PR #${{ steps.check.outputs.pr_number }} merged.
+          These learnings are accumulated from PR reviews and feedback."
+              git push
+            fi
+          fi
+        env:
+          LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO || '' }}
+          LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}

package/dist/index.js

@@ -9748,6 +9748,13 @@ async function loadPersistedState(cwd, storage) {
   } else {
     learningsPath = dir;
   }
+  if (!learningsPath && existsSync6(dir)) {
+    const { readdirSync } = await import("fs");
+    const files = readdirSync(dir).filter((f3) => f3.endsWith(".md"));
+    if (files.length > 0) {
+      learningsPath = dir;
+    }
+  }
   const codebaseIndex = await storage.load("codebase-index");
   if (codebaseIndex) {
     const cbDir = join6(cwd, ".jdi", "codebase");
@@ -11610,7 +11617,7 @@ function parseComment(comment, isFollowUp) {
     }
     return { ...base, command: "quick", description };
   }
-  if (/^(approved?|lgtm|looks?\s*good|ship\s*it)/i.test(lower)) {
+  if (/\b(approved?|lgtm|looks?\s*good|ship\s*it)\b/i.test(lower)) {
     return { ...base, command: "plan", description: body, clickUpUrl: null, isFeedback: true, isApproval: true };
   }
   if (isFollowUp) {
@@ -12287,7 +12294,7 @@ var stateCommand = defineCommand({
 // package.json
 var package_default = {
   name: "@benzotti/jedi",
-  version: "0.1.34",
+  version: "0.1.36",
   description: "JDI - Context-efficient AI development framework for Claude Code",
   type: "module",
   bin: {

package/framework/commands/create-plan.md

@@ -31,7 +31,7 @@ Create an implementation plan using a single planner agent (includes research).
 
 ## HARD STOP — Planning Gate
 
-After the user approves the plan, your work is **DONE**. Output: _"Plan approved and finalised. Run `/jdi:implement-plan` when ready to execute."_ Then **STOP completely**. Do NOT invoke `/jdi:implement-plan`, do NOT spawn implementation agents, do NOT begin writing source code. Planning and implementation are separate human-gated phases.
+After the user approves the plan, your work is **DONE**. Output: _"Plan approved and locked in. Let me know when you want to implement."_ Then **STOP completely**. Do NOT invoke `/jdi:implement-plan`, do NOT spawn implementation agents, do NOT begin writing source code. Planning and implementation are separate human-gated phases.
 
 Agent base (read FIRST for cache): .jdi/framework/components/meta/AgentBase.md | Agent spec: .jdi/framework/agents/jdi-planner.md
 

package/framework/templates/CLAUDE-SHARED.md

@@ -39,7 +39,7 @@ Follow response templates exactly as instructed in the prompt — do not improvi
 
 Planning and implementation are **separate human-gated phases**. NEVER auto-proceed to implementation after planning or plan refinement.
 
-- When the user says "approved" / "lgtm" / "looks good" to a **plan**: this means the plan is finalised. It does NOT mean "go implement it." Finalise the plan review, output _"Plan approved. Run `/jdi:implement-plan` when ready."_, then **STOP**.
+- When the user says "approved" / "lgtm" / "looks good" to a **plan**: this means the plan is finalised. It does NOT mean "go implement it." Finalise the plan review, output _"Plan approved and locked in. Let me know when you want to implement."_, then **STOP**.
 - When the user provides refinement feedback on a plan, ONLY update the plan files in `.jdi/plans/`. Do NOT implement code.
 - Implementation ONLY happens when the user explicitly requests it: "implement", "build", "execute", or `/jdi:implement-plan`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benzotti/jedi",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "JDI - Context-efficient AI development framework for Claude Code",
   "type": "module",
   "bin": {