@benzotti/jedi 0.1.38 → 0.1.40

package/action/workflow-template.yml

@@ -60,14 +60,13 @@ jobs:
       - name: Resolve PR branch
         id: pr
         run: |
-          if [ -n "$PR_HEAD_REF" ]; then
-            echo "branch=$PR_HEAD_REF" >> "$GITHUB_OUTPUT"
-          elif [ -n "$PR_NUMBER" ]; then
-            BRANCH=$(gh api repos/${{ github.repository }}/pulls/$PR_NUMBER --jq '.head.ref')
-            echo "branch=$BRANCH" >> "$GITHUB_OUTPUT"
-          fi
+          bunx @benzotti/jedi@latest action resolve-branch \
+            --repo "$REPO" \
+            ${PR_HEAD_REF:+--pr-head-ref "$PR_HEAD_REF"} \
+            ${PR_NUMBER:+--pr-number "$PR_NUMBER"}
         env:
           GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
           PR_HEAD_REF: ${{ github.event.pull_request.head.ref || '' }}
           PR_NUMBER: ${{ github.event.issue.number || github.event.pull_request.number || '' }}
 
@@ -100,66 +99,14 @@ jobs:
       # Bootstrap Jedi framework if not present (first run or cache miss)
       - name: Bootstrap Jedi
         run: |
-          if [ ! -d ".jdi/framework" ]; then
-            bunx @benzotti/jedi@latest init --ci
-          fi
-          mkdir -p .jdi/persistence
-
-          # If cache was restored from fallback (not exact branch match),
-          # clear plans and state — they're branch-local, only learnings carry forward
-          if [ "${{ steps.cache.outputs.cache-hit }}" != "true" ]; then
-            echo "Cache miss or fallback — clearing plan state"
-            rm -rf .jdi/plans/*
-            mkdir -p .jdi/config
-            printf 'active_plan: null\ncurrent_wave: null\nmode: null\n' > .jdi/config/state.yaml
-          fi
-
-          # Exclude Jedi working directories from git so they don't get committed
-          # or conflict with branch checkouts — they live in the cache only
-          mkdir -p .git/info
-          for pattern in '.jdi/' '.claude/'; do
-            grep -qxF "$pattern" .git/info/exclude 2>/dev/null || echo "$pattern" >> .git/info/exclude
-          done
+          bunx @benzotti/jedi@latest action bootstrap --cache-hit "${{ steps.cache.outputs.cache-hit }}"
 
       # 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"
-          REMOTE_SUBDIR="jedi/learnings"
-          mkdir -p "$LEARNINGS_DIR"
-
-          # Clone only the learnings directory (sparse checkout)
-          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 "$REMOTE_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/$REMOTE_SUBDIR" ]; then
-            for f in "$TMPDIR/$REMOTE_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 — continuing"
-          fi
-
-          rm -rf "$TMPDIR"
+          bunx @benzotti/jedi@latest action fetch-learnings --learnings-repo "$LEARNINGS_REPO"
         env:
           LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO }}
           LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}
@@ -183,7 +130,7 @@ jobs:
       #   Set JEDI_ALLOWED_USERS to a comma-separated list for explicit allow-listing.
       - name: Run Jedi
         run: |
-          bunx @benzotti/jedi@latest action "$COMMENT_BODY" \
+          bunx @benzotti/jedi@latest action run "$COMMENT_BODY" \
             --repo "$REPO" \
             ${COMMENT_ID:+--comment-id "$COMMENT_ID"} \
             ${PR_NUMBER:+--pr-number "$PR_NUMBER"} \
@@ -226,32 +173,10 @@ jobs:
       - 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
+          bunx @benzotti/jedi@latest action promote-learnings \
+            --check-only \
+            --repo "$REPO" \
+            --sha "${{ github.sha }}"
         env:
           GH_TOKEN: ${{ github.token }}
           REPO: ${{ github.repository }}
@@ -300,98 +225,14 @@ jobs:
           && steps.restore.outputs.cache-hit != ''
           && vars.JEDI_COMMIT_LEARNINGS == 'true'
         run: |
-          LEARNINGS_SRC=".jdi/framework/learnings"
-          REMOTE_SUBDIR="jedi/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, merge learnings, push ──
-            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/$REMOTE_SUBDIR"
-
-            # Merge learnings: append new lines from local that don't exist in remote
-            for f in "$LEARNINGS_SRC"/*.md; do
-              [ -f "$f" ] || continue
-              BASENAME=$(basename "$f")
-              REMOTE_FILE="$TMPDIR/$REMOTE_SUBDIR/$BASENAME"
-
-              if [ -f "$REMOTE_FILE" ]; then
-                # Append lines from local that aren't already in the remote file
-                while IFS= read -r line; do
-                  [ -z "$line" ] && continue
-                  if ! grep -qFx "$line" "$REMOTE_FILE" 2>/dev/null; then
-                    echo "$line" >> "$REMOTE_FILE"
-                  fi
-                done < "$f"
-                echo "Merged learning: $BASENAME"
-              else
-                cp "$f" "$REMOTE_FILE"
-                echo "Added new learning: $BASENAME"
-              fi
-            done
-
-            cd "$TMPDIR"
-            git config user.name "jedi[bot]"
-            git config user.email "jedi[bot]@users.noreply.github.com"
-            git add "$REMOTE_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}/$REMOTE_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
+          bunx @benzotti/jedi@latest action promote-learnings \
+            --repo "$REPO" \
+            --sha "${{ github.sha }}" \
+            --pr-number "${{ steps.check.outputs.pr_number }}" \
+            --branch "${{ steps.check.outputs.branch }}" \
+            ${LEARNINGS_REPO:+--learnings-repo "$LEARNINGS_REPO"}
         env:
           LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO || '' }}
           LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}

package/dist/index.js

@@ -11292,7 +11292,7 @@ var planApproveCommand = defineCommand({
   }
 });
 
-// src/commands/action.ts
+// src/commands/action/run.ts
 import { resolve as resolve11 } from "path";
 
 // src/utils/clickup.ts
@@ -11568,7 +11568,7 @@ function formatErrorComment(command, summary) {
 `);
 }
 
-// src/commands/action.ts
+// src/commands/action/run.ts
 function parseComment(comment, isFollowUp) {
   const hasDryRun = /--dry-run/i.test(comment);
   const cleanComment = comment.replace(/--dry-run/gi, "").trim();
@@ -11625,9 +11625,9 @@ function parseComment(comment, isFollowUp) {
   }
   return { ...base, command: "plan", description };
 }
-var actionCommand = defineCommand({
+var runCommand2 = defineCommand({
   meta: {
-    name: "action",
+    name: "run",
     description: "GitHub Action entry point \u2014 parse 'Hey Jedi' comment and run workflow"
   },
   args: {
@@ -12129,9 +12129,506 @@ Use the ClickUp ticket above as the primary requirements source.` : ``,
   }
 });
 
+// src/commands/action/resolve-branch.ts
+import { appendFileSync } from "fs";
+function writeGitHubOutput(key, value) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync(outputFile, `${key}=${value}
+`);
+  }
+  console.log(`${key}=${value}`);
+}
+function resolveBranch(opts) {
+  if (opts.prHeadRef) {
+    return opts.prHeadRef;
+  }
+  if (opts.prNumber && opts.repo) {
+    const result = Bun.spawnSync(["gh", "api", `repos/${opts.repo}/pulls/${opts.prNumber}`, "--jq", ".head.ref"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode === 0) {
+      const branch = result.stdout.toString().trim();
+      if (branch)
+        return branch;
+    } else {
+      consola.warn(`Failed to resolve branch via API: ${result.stderr.toString().trim()}`);
+    }
+  }
+  return null;
+}
+var resolveBranchCommand = defineCommand({
+  meta: {
+    name: "resolve-branch",
+    description: "Resolve the PR head branch for checkout"
+  },
+  args: {
+    "pr-head-ref": {
+      type: "string",
+      description: "The PR head ref (if available from event context)"
+    },
+    "pr-number": {
+      type: "string",
+      description: "The PR number to look up"
+    },
+    repo: {
+      type: "string",
+      description: "Repository in owner/repo format",
+      required: true
+    }
+  },
+  run({ args }) {
+    const branch = resolveBranch({
+      prHeadRef: args["pr-head-ref"],
+      prNumber: args["pr-number"],
+      repo: args.repo
+    });
+    if (branch) {
+      writeGitHubOutput("branch", branch);
+    } else {
+      consola.info("No branch resolved \u2014 no PR context available");
+    }
+  }
+});
+
+// src/commands/action/bootstrap.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, readFileSync, writeFileSync, rmSync, readdirSync } from "fs";
+import { join as join13 } from "path";
+function ensureFramework(cwd) {
+  const frameworkDir = join13(cwd, ".jdi/framework");
+  if (!existsSync14(frameworkDir)) {
+    consola.info("Framework not found \u2014 initializing...");
+    const result = Bun.spawnSync(["bunx", "@benzotti/jedi@latest", "init", "--ci"], {
+      cwd,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    if (result.exitCode !== 0) {
+      consola.error("Failed to initialize framework");
+      process.exit(1);
+    }
+  }
+  mkdirSync4(join13(cwd, ".jdi/persistence"), { recursive: true });
+}
+function clearStaleState(cwd) {
+  const plansDir = join13(cwd, ".jdi/plans");
+  if (existsSync14(plansDir)) {
+    for (const entry of readdirSync(plansDir)) {
+      rmSync(join13(plansDir, entry), { recursive: true, force: true });
+    }
+  } else {
+    mkdirSync4(plansDir, { recursive: true });
+  }
+  const configDir = join13(cwd, ".jdi/config");
+  mkdirSync4(configDir, { recursive: true });
+  writeFileSync(join13(configDir, "state.yaml"), `active_plan: null
+current_wave: null
+mode: null
+`);
+  consola.info("Cache miss or fallback \u2014 cleared plan state");
+}
+function setupGitExclude(cwd) {
+  const excludeDir = join13(cwd, ".git/info");
+  mkdirSync4(excludeDir, { recursive: true });
+  const excludePath = join13(excludeDir, "exclude");
+  let content = "";
+  if (existsSync14(excludePath)) {
+    content = readFileSync(excludePath, "utf-8");
+  }
+  const patterns = [".jdi/", ".claude/"];
+  for (const pattern of patterns) {
+    const lines = content.split(`
+`);
+    if (!lines.some((line) => line === pattern)) {
+      content = content.endsWith(`
+`) || content === "" ? content : content + `
+`;
+      content += pattern + `
+`;
+    }
+  }
+  writeFileSync(excludePath, content);
+}
+var bootstrapCommand = defineCommand({
+  meta: {
+    name: "bootstrap",
+    description: "Bootstrap Jedi framework, clear stale state, and configure git excludes"
+  },
+  args: {
+    "cache-hit": {
+      type: "string",
+      description: "Cache hit status from actions/cache ('true' if exact match)"
+    }
+  },
+  run({ args }) {
+    const cwd = process.cwd();
+    ensureFramework(cwd);
+    if (args["cache-hit"] !== "true") {
+      clearStaleState(cwd);
+    }
+    setupGitExclude(cwd);
+    consola.success("Bootstrap complete");
+  }
+});
+
+// src/commands/action/fetch-learnings.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync, rmSync as rmSync2 } from "fs";
+import { join as join14 } from "path";
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+function cloneLearningsRepo(repo, token, tmpDir) {
+  const cloneUrl = `https://x-access-token:${token}@github.com/${repo}.git`;
+  const cloneResult = Bun.spawnSync(["git", "clone", "--depth", "1", "--filter=blob:none", "--sparse", cloneUrl, tmpDir], { stdout: "pipe", stderr: "pipe" });
+  if (cloneResult.exitCode !== 0) {
+    consola.warn("Could not clone learnings repo \u2014 continuing without shared learnings");
+    return false;
+  }
+  Bun.spawnSync(["git", "sparse-checkout", "set", "jedi/learnings"], {
+    cwd: tmpDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return existsSync15(join14(tmpDir, "jedi/learnings"));
+}
+function mergeLearnings(sourceDir, targetDir) {
+  const result = { copied: 0, merged: 0 };
+  if (!existsSync15(sourceDir)) {
+    return result;
+  }
+  mkdirSync5(targetDir, { recursive: true });
+  const files = readdirSync2(sourceDir).filter((f3) => f3.endsWith(".md"));
+  for (const file of files) {
+    const sourcePath = join14(sourceDir, file);
+    const targetPath = join14(targetDir, file);
+    if (!existsSync15(targetPath)) {
+      copyFileSync(sourcePath, targetPath);
+      result.copied++;
+      consola.info(`Loaded shared learning: ${file}`);
+    } else {
+      const sourceContent = readFileSync2(sourcePath, "utf-8");
+      const targetContent = readFileSync2(targetPath, "utf-8");
+      const targetLines = new Set(targetContent.split(`
+`));
+      const newLines = [];
+      for (const line of sourceContent.split(`
+`)) {
+        if (line.trim() === "")
+          continue;
+        if (!targetLines.has(line)) {
+          newLines.push(line);
+        }
+      }
+      if (newLines.length > 0) {
+        const appendContent = (targetContent.endsWith(`
+`) ? "" : `
+`) + newLines.join(`
+`) + `
+`;
+        writeFileSync2(targetPath, targetContent + appendContent);
+        result.merged++;
+        consola.info(`Merged ${newLines.length} new lines into ${file}`);
+      } else {
+        consola.info(`No new learnings to merge for ${file}`);
+      }
+    }
+  }
+  return result;
+}
+var fetchLearningsCommand = defineCommand({
+  meta: {
+    name: "fetch-learnings",
+    description: "Fetch and merge shared learnings from an external repository"
+  },
+  args: {
+    "learnings-repo": {
+      type: "string",
+      description: "External learnings repository (e.g. org/jedi-learnings)"
+    },
+    "learnings-token": {
+      type: "string",
+      description: "Token for accessing the learnings repo"
+    }
+  },
+  run({ args }) {
+    const learningsRepo = args["learnings-repo"];
+    if (!learningsRepo) {
+      consola.info("No learnings repo configured \u2014 skipping");
+      return;
+    }
+    const token = args["learnings-token"] || process.env.LEARNINGS_TOKEN || process.env.GH_TOKEN || "";
+    if (!token) {
+      consola.warn("No token available for learnings repo \u2014 skipping");
+      return;
+    }
+    const cwd = process.cwd();
+    const learningsDir = join14(cwd, ".jdi/framework/learnings");
+    mkdirSync5(learningsDir, { recursive: true });
+    const tmpDir = mkdtempSync(join14(tmpdir(), "jedi-learnings-"));
+    try {
+      const cloned = cloneLearningsRepo(learningsRepo, token, tmpDir);
+      if (!cloned) {
+        return;
+      }
+      const sourceDir = join14(tmpDir, "jedi/learnings");
+      const result = mergeLearnings(sourceDir, learningsDir);
+      consola.success(`Learnings fetch complete (copied: ${result.copied}, merged: ${result.merged})`);
+    } finally {
+      rmSync2(tmpDir, { recursive: true, force: true });
+    }
+  }
+});
+
+// src/commands/action/promote-learnings.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, appendFileSync as appendFileSync2 } from "fs";
+import { join as join15 } from "path";
+import { mkdtempSync as mkdtempSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+function writeGitHubOutput2(key, value) {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync2(outputFile, `${key}=${value}
+`);
+  }
+  console.log(`${key}=${value}`);
+}
+function checkJediInvolvement(repo, sha) {
+  const prResult = Bun.spawnSync(["gh", "api", `repos/${repo}/commits/${sha}/pulls`, "--jq", ".[0].number // empty"], { stdout: "pipe", stderr: "pipe" });
+  const prNumberStr = prResult.stdout.toString().trim();
+  if (!prNumberStr) {
+    consola.info("No associated PR found \u2014 skipping");
+    return { skip: true };
+  }
+  const prNumber = parseInt(prNumberStr, 10);
+  const commentsResult = Bun.spawnSync([
+    "gh",
+    "api",
+    `repos/${repo}/issues/${prNumber}/comments`,
+    "--paginate",
+    "--jq",
+    `[.[] | select(.user.login == "github-actions[bot]" and (.body | test("jedi|Jedi")))] | length`
+  ], { stdout: "pipe", stderr: "pipe" });
+  const jediActivity = parseInt(commentsResult.stdout.toString().trim() || "0", 10);
+  const commitsResult = Bun.spawnSync([
+    "gh",
+    "api",
+    `repos/${repo}/pulls/${prNumber}/commits`,
+    "--paginate",
+    "--jq",
+    `[.[] | select(.commit.author.name == "jedi[bot]")] | length`
+  ], { stdout: "pipe", stderr: "pipe" });
+  const jediCommits = parseInt(commitsResult.stdout.toString().trim() || "0", 10);
+  if (jediActivity > 0 || jediCommits > 0) {
+    const branchResult = Bun.spawnSync(["gh", "api", `repos/${repo}/pulls/${prNumber}`, "--jq", ".head.ref"], { stdout: "pipe", stderr: "pipe" });
+    const branch = branchResult.stdout.toString().trim();
+    consola.info(`Jedi was active on PR #${prNumber} (comments: ${jediActivity}, commits: ${jediCommits}) \u2014 promoting learnings`);
+    return { skip: false, branch, prNumber };
+  }
+  consola.info(`No Jedi activity on PR #${prNumber} \u2014 skipping`);
+  return { skip: true };
+}
+function hasLearningsContent(learningsDir) {
+  if (!existsSync16(learningsDir)) {
+    return false;
+  }
+  const files = readdirSync3(learningsDir).filter((f3) => f3.endsWith(".md"));
+  for (const file of files) {
+    const content = readFileSync3(join15(learningsDir, file), "utf-8");
+    const lines = content.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("<!--")) {
+        continue;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function commitLearningsToSameRepo(learningsDir, prNumber) {
+  const addResult = Bun.spawnSync(["git", "add", `${learningsDir}/*.md`], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (addResult.exitCode !== 0) {
+    Bun.spawnSync(["bash", "-c", `git add "${learningsDir}"/*.md`], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+  }
+  const diffResult = Bun.spawnSync(["git", "diff", "--cached", "--quiet"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (diffResult.exitCode === 0) {
+    consola.info("Learnings unchanged \u2014 nothing to commit");
+    return false;
+  }
+  const message = prNumber ? `chore(jedi): update team learnings
+
+Auto-committed by Jedi after PR #${prNumber} merged.
+These learnings are accumulated from PR reviews and feedback.` : `chore(jedi): update team learnings`;
+  const commitResult = Bun.spawnSync(["git", "commit", "-m", message], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (commitResult.exitCode !== 0) {
+    consola.error("Failed to commit learnings:", commitResult.stderr.toString());
+    return false;
+  }
+  const pushResult = Bun.spawnSync(["git", "push"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (pushResult.exitCode !== 0) {
+    consola.error("Failed to push learnings:", pushResult.stderr.toString());
+    return false;
+  }
+  consola.success("Learnings committed and pushed");
+  return true;
+}
+function commitLearningsToExternalRepo(learningsDir, externalRepo, token, prNumber, sourceRepo) {
+  const tmpDir = mkdtempSync2(join15(tmpdir2(), "jedi-promote-"));
+  try {
+    const cloneUrl = `https://x-access-token:${token}@github.com/${externalRepo}.git`;
+    const cloneResult = Bun.spawnSync(["git", "clone", "--depth", "1", cloneUrl, tmpDir], { stdout: "pipe", stderr: "pipe" });
+    if (cloneResult.exitCode !== 0) {
+      consola.warn(`Could not clone learnings repo ${externalRepo} \u2014 skipping commit`);
+      return false;
+    }
+    const remoteSubdir = join15(tmpDir, "jedi/learnings");
+    mkdirSync6(remoteSubdir, { recursive: true });
+    mergeLearnings(learningsDir, remoteSubdir);
+    Bun.spawnSync(["git", "config", "user.name", "jedi[bot]"], { cwd: tmpDir });
+    Bun.spawnSync(["git", "config", "user.email", "jedi[bot]@users.noreply.github.com"], { cwd: tmpDir });
+    Bun.spawnSync(["bash", "-c", `git add "jedi/learnings"/*.md`], {
+      cwd: tmpDir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const diffResult = Bun.spawnSync(["git", "diff", "--cached", "--quiet"], {
+      cwd: tmpDir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (diffResult.exitCode === 0) {
+      consola.info("Learnings unchanged in external repo \u2014 nothing to commit");
+      return false;
+    }
+    const source = sourceRepo || "unknown";
+    const prRef = prNumber ? `PR #${prNumber}` : "merge";
+    const message = `chore(jedi): update learnings from ${source}
+
+Source: ${prRef} on ${source}
+Learnings accumulated from PR reviews and feedback.`;
+    const commitResult = Bun.spawnSync(["git", "commit", "-m", message], {
+      cwd: tmpDir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (commitResult.exitCode !== 0) {
+      consola.error("Failed to commit to external repo:", commitResult.stderr.toString());
+      return false;
+    }
+    const pushResult = Bun.spawnSync(["git", "push"], {
+      cwd: tmpDir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (pushResult.exitCode !== 0) {
+      consola.error("Failed to push to external repo:", pushResult.stderr.toString());
+      return false;
+    }
+    consola.success(`Learnings committed to ${externalRepo}/jedi/learnings`);
+    return true;
+  } finally {
+    rmSync3(tmpDir, { recursive: true, force: true });
+  }
+}
+var promoteLearningsCommand = defineCommand({
+  meta: {
+    name: "promote-learnings",
+    description: "Check Jedi involvement and promote learnings after PR merge"
+  },
+  args: {
+    repo: {
+      type: "string",
+      description: "Repository in owner/repo format",
+      required: true
+    },
+    sha: {
+      type: "string",
+      description: "The merge commit SHA",
+      required: true
+    },
+    "check-only": {
+      type: "boolean",
+      description: "Only check involvement, write outputs, and exit"
+    },
+    "pr-number": {
+      type: "string",
+      description: "PR number (if already known)"
+    },
+    branch: {
+      type: "string",
+      description: "Branch name (if already known)"
+    },
+    "learnings-repo": {
+      type: "string",
+      description: "External learnings repository"
+    },
+    "learnings-token": {
+      type: "string",
+      description: "Token for the learnings repo"
+    }
+  },
+  run({ args }) {
+    const repo = args.repo;
+    const sha = args.sha;
+    if (args["check-only"]) {
+      const involvement = checkJediInvolvement(repo, sha);
+      writeGitHubOutput2("skip", String(involvement.skip));
+      if (involvement.branch) {
+        writeGitHubOutput2("branch", involvement.branch);
+      }
+      if (involvement.prNumber) {
+        writeGitHubOutput2("pr_number", String(involvement.prNumber));
+      }
+      return;
+    }
+    const cwd = process.cwd();
+    const learningsDir = join15(cwd, ".jdi/framework/learnings");
+    if (!hasLearningsContent(learningsDir)) {
+      consola.info("No learnings content to commit \u2014 skipping");
+      return;
+    }
+    const learningsRepo = args["learnings-repo"];
+    const token = args["learnings-token"] || process.env.LEARNINGS_TOKEN || process.env.GH_TOKEN || "";
+    const prNumber = args["pr-number"] ? parseInt(args["pr-number"], 10) : undefined;
+    if (learningsRepo) {
+      commitLearningsToExternalRepo(learningsDir, learningsRepo, token, prNumber, repo);
+    } else {
+      commitLearningsToSameRepo(learningsDir, prNumber);
+    }
+  }
+});
+
+// src/commands/action/index.ts
+var actionCommand = defineCommand({
+  meta: {
+    name: "action",
+    description: "GitHub Action commands \u2014 run workflows, bootstrap, manage learnings"
+  },
+  subCommands: {
+    run: runCommand2,
+    "resolve-branch": resolveBranchCommand,
+    bootstrap: bootstrapCommand,
+    "fetch-learnings": fetchLearningsCommand,
+    "promote-learnings": promoteLearningsCommand
+  }
+});
+
 // src/commands/setup-action.ts
-import { join as join13, dirname as dirname3 } from "path";
-import { existsSync as existsSync14, mkdirSync as mkdirSync4 } from "fs";
+import { join as join16, dirname as dirname3 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7 } from "fs";
 var setupActionCommand = defineCommand({
   meta: {
     name: "setup-action",
@@ -12140,19 +12637,19 @@ var setupActionCommand = defineCommand({
   args: {},
   async run() {
     const cwd = process.cwd();
-    const workflowDest = join13(cwd, ".github", "workflows", "jedi.yml");
-    if (existsSync14(workflowDest)) {
+    const workflowDest = join16(cwd, ".github", "workflows", "jedi.yml");
+    if (existsSync17(workflowDest)) {
       consola.warn(`Workflow already exists at ${workflowDest}`);
       consola.info("Skipping workflow copy. Delete it manually to regenerate.");
     } else {
-      const templatePath = join13(import.meta.dir, "../action/workflow-template.yml");
-      if (!existsSync14(templatePath)) {
+      const templatePath = join16(import.meta.dir, "../action/workflow-template.yml");
+      if (!existsSync17(templatePath)) {
         consola.error("Workflow template not found. Ensure @benzotti/jedi is properly installed.");
         process.exit(1);
       }
       const dir = dirname3(workflowDest);
-      if (!existsSync14(dir))
-        mkdirSync4(dir, { recursive: true });
+      if (!existsSync17(dir))
+        mkdirSync7(dir, { recursive: true });
       const template = await Bun.file(templatePath).text();
       await Bun.write(workflowDest, template);
       consola.success(`Created ${workflowDest}`);
@@ -12294,7 +12791,7 @@ var stateCommand = defineCommand({
 // package.json
 var package_default = {
   name: "@benzotti/jedi",
-  version: "0.1.38",
+  version: "0.1.40",
   description: "JDI - Context-efficient AI development framework for Claude Code",
   type: "module",
   bin: {

package/package.json

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