@codyswann/lisa 4.74.9 → 4.75.0

package/plugins/lisa-devin/hooks/inject-resolved-config.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# SessionStart / SubagentStart: put the RESOLVED Lisa configuration in front of
+# the agent, so reading it is not a decision anyone can decline to make.
+#
+# `inject-rules.sh` beside this file injects RULE TEXT. Nothing injected the
+# resolved VALUES, so an agent received a paragraph saying that configuration
+# lives in a file and then had to decide, unprompted, to go read it. That
+# decision is the step that gets skipped, and it is why projects keep "missing"
+# a `.lisa.config.json` that is present and correct. An agent cannot skip
+# reading what is already in its context.
+#
+# All the work — resolving `.lisa.config.local.json` over `.lisa.config.json`,
+# marking built-in defaults, redacting identity, bounding the output — lives in
+# the sibling `.mjs`, which is unit-tested. This wrapper only resolves the
+# project root and hands stdin through.
+#
+# FAIL SOFT, ALWAYS. Every exit is 0 and every failure is silent. The right
+# response to "node is missing" or "the renderer crashed" is a session that
+# starts without this block, never a session that does not start. The hard
+# reading of the same config lives where it can afford to be hard: the gate
+# runner refuses a config it cannot read, and `lisa doctor` exits non-zero.
+#
+# Note the ONE case that is emphatically not silent: a config that exists and
+# is malformed emits a block saying so. Staying quiet there would report a
+# broken project as an unconfigured one, which is the invisible-gap failure
+# this hook exists to remove.
+set -uo pipefail
+
+INPUT=$(cat 2>/dev/null || true)
+
+ROOT="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}"
+RENDERER="$ROOT/hooks/inject-resolved-config.mjs"
+
+[ -f "$RENDERER" ] || exit 0
+command -v node >/dev/null 2>&1 || exit 0
+
+# CLAUDE_PROJECT_DIR is the harness's own declaration of the root and is the
+# only source that stays correct when the session's cwd has moved. Falling back
+# to the git toplevel before $PWD matters for the same reason: config lives at
+# the repo root, and a hook that reads the cwd reports "unconfigured" from any
+# subdirectory (the defect fixed for setup-jira-cli in CodySwannGT/lisa#2768).
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-}"
+if [ -z "${PROJECT_DIR}" ] || [ ! -d "${PROJECT_DIR}" ]; then
+  PROJECT_DIR="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+fi
+
+# ...but the harness sets CLAUDE_PROJECT_DIR to wherever the session STARTED,
+# which in a monorepo is routinely a subdirectory. Validating only that the
+# directory exists left the git fallback above unreachable in exactly that case,
+# so a fully configured repository reported "No Lisa configuration found" — the
+# loudest possible wrong answer, in the one state this hook exists to make loud.
+#
+# So walk up for the config instead of assuming the declared directory holds it.
+# The repository root bounds the walk: a config file ABOVE it belongs to some
+# other project, and adopting it would be the same wrong answer wearing a
+# different hat.
+#
+# `git rev-parse --show-toplevel` — the same command the PROJECT_DIR fallback
+# above already runs — is the authoritative answer to "where does this work tree
+# end". `.git`-presence is only a proxy for it, and the two part company on any
+# layout that relocates the git directory (GIT_DIR/GIT_WORK_TREE set
+# explicitly): the proxy never fires, the walk leaves the repository, and the
+# block renders a neighbouring project's config as though it were this one
+# (CodySwannGT/lisa#3623). So bound on the toplevel, and keep the `.git`-presence
+# proxy for the case the toplevel cannot answer — no repository, or no git.
+# `.git` is a file in a worktree and a directory otherwise, hence `-e`.
+#
+# Both paths are compared in PHYSICAL form, because `--show-toplevel` resolves
+# symlinks and the harness-declared directory does not. On any box whose
+# temporary or home directory is a symlink (macOS `/var` -> `/private/var`) a
+# textual comparison of the two never matches, and a bound that never matches is
+# the unbounded walk again.
+#
+# There is no depth cap. The one that was here claimed to be a symlink-loop
+# guard and could not be: `dirname` is string manipulation, resolves no symlinks,
+# and strictly shortens. What it could do was stop a legitimate walk at 32 levels
+# and report "No Lisa configuration found" for a repository that has one — the
+# loudest possible wrong answer, in the one state this hook exists to make loud.
+# Termination is guarded by the thing that actually threatens it: `dirname`
+# reaching a fixed point (`/` -> `/`, and `.` -> `.` for a relative input).
+config_root() {
+  local dir parent repo_root
+  # Physical form, so the comparison against the toplevel below is like-for-like.
+  dir="$(cd "$1" 2>/dev/null && pwd -P)" || dir="$1"
+  [ -n "${dir}" ] || dir="$1"
+  repo_root="$(git -C "${dir}" rev-parse --show-toplevel 2>/dev/null || true)"
+  while [ -n "${dir}" ] && [ "${dir}" != "/" ]; do
+    if [ -f "${dir}/.lisa.config.json" ] || [ -f "${dir}/.lisa.config.local.json" ]; then
+      printf '%s' "${dir}"
+      return 0
+    fi
+    if [ -n "${repo_root}" ]; then
+      [ "${dir}" = "${repo_root}" ] && return 1
+    elif [ -e "${dir}/.git" ]; then
+      return 1
+    fi
+    parent="$(dirname "${dir}")"
+    [ "${parent}" = "${dir}" ] && return 1
+    dir="${parent}"
+  done
+  return 1
+}
+
+CONFIG_DIR="$(config_root "${PROJECT_DIR}")" && PROJECT_DIR="${CONFIG_DIR}"
+
+printf '%s' "$INPUT" | node "$RENDERER" --project-dir "$PROJECT_DIR" || true
+exit 0

package/plugins/lisa-devin/hooks/inject-rules.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# Reads all .md files from the plugin's rules/eager/ directory and injects them
+# into the session context via hookSpecificOutput.additionalContext.
+# Used by SessionStart and SubagentStart hooks.
+#
+# The split between eager and reference rules is documented in
+# rules/eager/00-bootstrap.md (or the equivalent README). Reference bodies
+# under rules/reference/ are installed alongside but loaded only when the
+# eager breadcrumb points to them.
+set -euo pipefail
+
+INPUT=$(cat 2>/dev/null || true)
+if [ -n "$INPUT" ]; then
+  HOOK_EVENT=$(printf '%s' "$INPUT" | jq -r '.hook_event_name // "SessionStart"' 2>/dev/null || echo "SessionStart")
+else
+  HOOK_EVENT="SessionStart"
+fi
+
+ROOT="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}"
+RULES_DIR="$ROOT/rules/eager"
+
+# There is deliberately NO fallback to a flat rules/ directory (#3993).
+#
+# It existed to cover an "older Lisa install", but a plugin's rules and this
+# script ship in the same directory and install as one unit, so that skew cannot
+# arise. What the branch actually did was absorb plugins that never adopted the
+# split: `lisa-phaser` shipped a flat 11,007-byte rules/phaser.md on 2026-06-11,
+# two weeks AFTER the split commit a820527 (2026-05-28), and the fallback
+# injected the whole body at every SessionStart and SubagentStart without any
+# surface reporting it. A quiet success is indistinguishable from a tree that was
+# never split. With the branch gone, an unsplit plugin injects nothing and gets
+# noticed. (The Codex mirror injector keeps its fallback: `.codex/lisa-rules/` is
+# written separately from the script that reads it, so vintage skew IS possible
+# there.)
+
+# Bail silently if no rules directory at all
+[ -d "$RULES_DIR" ] || exit 0
+
+CONTEXT=""
+for file in "$RULES_DIR"/*.md; do
+  [ -f "$file" ] || continue
+  CONTEXT+="$(cat "$file")"$'\n\n'
+done
+
+# Bail if no rules found
+[ -n "$CONTEXT" ] || exit 0
+
+# Output as JSON — jq handles escaping
+jq -n --arg event "$HOOK_EVENT" --arg ctx "$CONTEXT" '{"hookSpecificOutput": {"hookEventName": $event, "additionalContext": $ctx}}'

package/plugins/lisa-devin/hooks/install-pkgs.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# This file is managed by Lisa.
+# Do not edit directly — changes will be overwritten on the next `lisa` run.
+
+# Drain the hook envelope before any early return. The script does not inspect
+# it, but Codex/Cursor-compatible runners may stream it through a bounded pipe.
+cat >/dev/null 2>&1 || true
+
+link_primary_worktree_node_modules() {
+  [ -f "package.json" ] || return 1
+  [ ! -e "node_modules" ] && [ ! -L "node_modules" ] || return 1
+
+  repo_root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+  # A linked worktree's --git-common-dir is <primary>/.git no matter where the
+  # worktree lives (.claude/worktrees, ~/.codex/worktrees, plain
+  # `git worktree add`), so derive the primary checkout from it. Fall back to
+  # the legacy .claude path parse on git <2.31 (no --path-format support).
+  git_common_dir="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)"
+  if [ -n "$git_common_dir" ]; then
+    primary_root="$(dirname "$git_common_dir")"
+  else
+    case "$repo_root" in
+      */.claude/worktrees/*)
+        primary_root="${repo_root%%/.claude/worktrees/*}"
+        ;;
+      *)
+        return 1
+        ;;
+    esac
+  fi
+
+  [ "$primary_root" != "$repo_root" ] || return 1
+  [ -d "$primary_root/node_modules" ] || return 1
+
+  ln -s "$primary_root/node_modules" "node_modules"
+  echo "Linked node_modules from primary worktree: $primary_root/node_modules" >&2
+}
+
+# Only run package installation when node_modules are missing.
+# This covers remote environments, new worktrees, fresh clones, and CI.
+if [ -d "node_modules" ]; then
+  exit 0
+fi
+
+if link_primary_worktree_node_modules && [ -d "node_modules" ]; then
+  exit 0
+fi
+
+# Detect the package manager this project wants, honoring explicit opt-outs.
+# Precedence: packageManager field > engines "please-use-<pm>" sentinel >
+# lockfile presence (minus any PM the engines forbid) > npm default.
+#
+# This must NOT key on lockfile presence alone. An npm-only project
+# (engines.bun = "please-use-npm", CI runs `npm ci`) that picks up a stray
+# bun.lock would otherwise get `bun install`, re-create the bun.lock, and break
+# — the package-manager selection regression. The engines/packageManager signals are
+# authoritative; lockfiles are only a fallback and never override an opt-out.
+detect_package_manager() {
+  _field="" _forced="" _forbidden=""
+  if [ -f package.json ] && command -v jq >/dev/null 2>&1; then
+    _field=$(jq -r '(.packageManager // "") | sub("@.*$";"")' package.json 2>/dev/null)
+    _forced=$(jq -r 'first((.engines // {})[] | strings | capture("please-use-(?<pm>bun|npm|yarn|pnpm)")?.pm) // ""' package.json 2>/dev/null)
+    _forbidden=$(jq -r '[(.engines // {}) | to_entries[] | select(((.value|strings) // "") | test("please-use|do-not-use";"i")) | .key] | join(" ")' package.json 2>/dev/null)
+  fi
+  case "$_field" in bun | npm | yarn | pnpm) printf '%s\n' "$_field"; return 0 ;; esac
+  case "$_forced" in bun | npm | yarn | pnpm) printf '%s\n' "$_forced"; return 0 ;; esac
+  _pm_allowed() { case " $_forbidden " in *" $1 "*) return 1 ;; *) return 0 ;; esac; }
+  if { [ -f bun.lockb ] || [ -f bun.lock ]; } && _pm_allowed bun; then printf 'bun\n'; return 0; fi
+  if [ -f pnpm-lock.yaml ] && _pm_allowed pnpm; then printf 'pnpm\n'; return 0; fi
+  if [ -f yarn.lock ] && _pm_allowed yarn; then printf 'yarn\n'; return 0; fi
+  if [ -f package-lock.json ] && _pm_allowed npm; then printf 'npm\n'; return 0; fi
+  printf 'npm\n'
+}
+
+PACKAGE_MANAGER="$(detect_package_manager)"
+echo "Detected package manager: ${PACKAGE_MANAGER}" >&2
+case "$PACKAGE_MANAGER" in
+  bun) bun install >&2 ;;
+  pnpm) pnpm install >&2 ;;
+  yarn) yarn install >&2 ;;
+  *) npm install >&2 ;;
+esac
+
+exit 0