@codyswann/lisa 4.74.9 → 4.75.0

package/plugins/lisa-wiki-devin/templates/state-readme.md

@@ -0,0 +1,20 @@
+# state/ — ingestion cursors
+
+JSON cursors that let ingestion resume incrementally — one file per source/connector at
+`state/<system>/*.json`. A cursor is advanced **only after** its source notes + synthesis + index +
+log + verification all pass (never before). Common envelope:
+
+```json
+{
+  "connector": "git",
+  "profile": "default",
+  "lastSuccessfulRunAt": "1970-01-01T00:00:00Z",
+  "cursor": {},
+  "sourceNotes": [],
+  "synthesisPages": [],
+  "schemaVersion": "1.0.0"
+}
+```
+
+The post-migration / post-setup verification report is written to
+`state/migration/doctor-report.json` by `/doctor`.

package/plugins/lisa-wiki-devin/templates/wrapper-gitignore.txt

@@ -0,0 +1,19 @@
+# BEGIN: AI GUARDRAILS WIKI
+# Managed by the lisa-wiki kernel. Do not edit between these markers — re-run
+# /lisa-wiki:setup (or the equivalent script) to update. Patterns outside the
+# block are preserved untouched. The "WIKI" suffix lets this block coexist
+# with the base lisa plugin's "# BEGIN: AI GUARDRAILS" block when both are
+# installed (the copy-contents strategy keys on the marker suffix).
+
+# Claude Code per-session git worktrees. Each Claude session that needs an
+# isolated working copy spawns one under .claude/worktrees/ (via
+# `git worktree add`). They are transient, large (often hundreds of MB each),
+# and per-developer; they must never be committed.
+/.claude/worktrees/
+
+# Codex CLI per-session worktrees (Codex equivalent of the above).
+/.codex/worktrees/
+
+# Lisa backup snapshots (created by `lisa` runs).
+/.lisabak/
+# END: AI GUARDRAILS WIKI

package/scripts/build-plugins.sh

@@ -322,11 +322,11 @@ done
 # wiki/architecture/pattern-b-fan-out-spec.md).
 #
 # Fan out EVERY built Claude plugin (base + every stack + standalones) to each
-# per-agent runtime so cursor/agy/copilot reach parity with Claude/Codex on
+# per-agent runtime so cursor/agy/copilot/devin reach parity with Claude/Codex on
 # stack-specific functionality, not just the base governance plugin. The base
 # keeps its short name `lisa-<agent>`; every other plugin becomes
 # `<plugin>-<agent>` (e.g. lisa-typescript-cursor).
-PER_AGENT_VARIANTS=(cursor agy copilot)
+PER_AGENT_VARIANTS=(cursor agy copilot devin)
 FANOUT_SOURCES=(lisa)
 for stack in "${STACKS[@]}"; do FANOUT_SOURCES+=("lisa-$stack"); done
 for name in "${STANDALONE[@]}"; do FANOUT_SOURCES+=("lisa-$name"); done

package/scripts/deployed-guard-advice.mjs

@@ -141,6 +141,7 @@ export const SOURCE_GUARD_ROOTS = Object.freeze([
   "plugins/lisa-agy/hooks",
   "plugins/lisa-cursor/hooks",
   "plugins/lisa-copilot/hooks",
+  "plugins/lisa-devin/hooks",
   "all/copy-overwrite/scripts/lisa-hooks",
 ]);
 

package/scripts/generate-devin-plugin-artifacts.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Generate the Devin CLI variant of a Lisa plugin from the built Claude
+ * artifact.
+ *
+ * Devin installs plugins natively (`devin plugins install <path>`) and reads
+ * `.devin-plugin/plugin.json` first, falling back to `.claude-plugin/plugin.json`.
+ * Skills (`skills/<n>/SKILL.md`), agents (`agents/<n>.md`, exposed as
+ * `<plugin>:<n>`), and a root `.mcp.json` load unchanged, so most of the
+ * Claude artifact ships as-is. What does NOT carry over — each measured by run
+ * on Devin CLI 3000.11.3 (CodySwannGT/lisa#4426):
+ *
+ *   - Hooks. Devin loads plugin hooks only from a ROOT `hooks.json`; the inline
+ *     `hooks` block Lisa's Claude build writes into the manifest is ignored.
+ *   - Tool names. Devin's tools are `exec`, `write`, `edit`, `read`, … — a
+ *     Claude matcher like `Bash` never fires, and Lisa's guards test
+ *     `tool_name == "Bash"`, so even a firing hook would stand down. The
+ *     variant translates matchers and routes every handler through a shim that
+ *     maps the payload's tool name back to Claude's (see
+ *     `buildDevinHooksJson` in scripts/lib/per-agent-hook-filter.mjs).
+ *   - Commands. Devin has no plugin command surface; its slash commands are
+ *     skills (`/<plugin>:<skill>`). Lisa's `commands/` are thin pass-throughs
+ *     to hyphenated skills, so they are dropped and the skills carry the
+ *     workflow. Documented gap: `/lisa:implement` is spelled
+ *     `/lisa:lisa-implement` on Devin.
+ *
+ * The plugin keeps the Claude plugin's `name` (`lisa`, `lisa-typescript`, …) so
+ * agent references such as `lisa:verification-specialist` resolve to the same
+ * namespace they do on Claude.
+ *
+ * Usage: node scripts/generate-devin-plugin-artifacts.mjs <source-plugin-dir> <out-dir> <version>
+ *
+ * @module scripts/generate-devin-plugin-artifacts
+ */
+import fs from "node:fs";
+import path from "node:path";
+import {
+  buildDevinHooksJson,
+  DEVIN_TOOL_SHIM,
+  filterScriptsForAgent,
+} from "./lib/per-agent-hook-filter.mjs";
+import { invokedAsScript } from "./lib/invoked-as-script.mjs";
+import { rewritePluginRuleCitations } from "./lib/plugin-rule-citations.mjs";
+
+/** Manifest filename shared by the Claude and Devin manifest directories. */
+const PLUGIN_JSON = "plugin.json";
+
+/** Manifest fields Devin's `.devin-plugin/plugin.json` documents as metadata. */
+const DEVIN_MANIFEST_FIELDS = Object.freeze([
+  "name",
+  "version",
+  "description",
+  "author",
+  "homepage",
+  "repository",
+  "license",
+  "keywords",
+]);
+
+/**
+ * Devin → Claude tool-name shim, emitted into every Devin variant that ships
+ * hooks. It reads the hook payload, rewrites a lowercase Devin `tool_name` to
+ * the Claude name the guard tests for, and pipes the result into the wrapped
+ * hook command, preserving its exit status and output. Without `jq` (which the
+ * guards themselves require) the payload passes through unchanged.
+ */
+const DEVIN_TOOL_SHIM_SOURCE = `#!/bin/sh
+# Generated by scripts/generate-devin-plugin-artifacts.mjs — do not edit.
+#
+# Devin CLI names its tools in lowercase (exec, write, edit, read, ...) while
+# Lisa's guards test Claude's names (Bash, Write, Edit, Read, ...). The field
+# names inside tool_input already match, so translating tool_name is enough
+# for an unchanged guard to evaluate a Devin tool call (CodySwannGT/lisa#4426).
+#
+# Usage: devin-tool-name-shim.sh <hook command> [args...]
+payload=$(cat)
+normalized=$payload
+if command -v jq >/dev/null 2>&1; then
+  mapped=$(printf '%s' "$payload" | jq -c '
+    if (.tool_name | type) == "string" then
+      .tool_name |= ({
+        "exec": "Bash",
+        "write": "Write",
+        "edit": "Edit",
+        "read": "Read",
+        "notebook_edit": "NotebookEdit",
+        "grep": "Grep",
+        "glob": "Glob",
+        "webfetch": "WebFetch",
+        "run_subagent": "Task",
+        "skill": "Skill",
+        "todo_write": "TodoWrite"
+      }[.] // .)
+    else . end' 2>/dev/null) && [ -n "$mapped" ] && normalized=$mapped
+fi
+printf '%s' "$normalized" | "$@"
+`;
+
+/**
+ * Recursive directory copy with a path-level filter. File modes are preserved
+ * so hook scripts stay executable.
+ *
+ * @param {string} src
+ * @param {string} dst
+ * @param {(relPath: string) => boolean} keep
+ */
+function copyDir(src, dst, keep) {
+  fs.mkdirSync(dst, { recursive: true });
+  const walk = (current, rel) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const relPath = path.join(rel, entry.name);
+      if (!keep(relPath)) continue;
+      const srcPath = path.join(current, entry.name);
+      const dstPath = path.join(dst, relPath);
+      if (entry.isDirectory()) {
+        fs.mkdirSync(dstPath, { recursive: true });
+        walk(srcPath, relPath);
+      } else if (entry.isFile()) {
+        fs.copyFileSync(srcPath, dstPath);
+        fs.chmodSync(dstPath, fs.statSync(srcPath).mode);
+      }
+    }
+  };
+  walk(src, "");
+}
+
+/**
+ * Whether a source-relative path belongs in the Devin variant.
+ *
+ * @param {string} relPath
+ * @returns {boolean}
+ */
+function keepForDevin(relPath) {
+  const top = relPath.split(path.sep)[0];
+  // Codex manifest + hooks: a different runtime's surface.
+  if (top === ".codex-plugin") return false;
+  // Devin has no plugin command surface; the skills carry these workflows.
+  if (top === "commands") return false;
+  // Codex-only per-skill agent metadata.
+  if (/^skills\/[^/]+\/agents\/openai\.ya?ml$/.test(relPath)) return false;
+  return true;
+}
+
+/**
+ * Remove `skills/<n>/agents/` directories left empty by the openai.yaml strip.
+ *
+ * @param {string} outDir
+ */
+function pruneEmptySkillAgentDirs(outDir) {
+  const skillsDir = path.join(outDir, "skills");
+  if (!fs.existsSync(skillsDir)) return;
+  for (const skillName of fs.readdirSync(skillsDir)) {
+    const agentsDir = path.join(skillsDir, skillName, "agents");
+    if (fs.existsSync(agentsDir) && fs.readdirSync(agentsDir).length === 0) {
+      fs.rmdirSync(agentsDir);
+    }
+  }
+}
+
+/**
+ * Keep only the hook scripts the Devin ship list allows, then add the shim
+ * when any hook survives.
+ *
+ * @param {string} outDir
+ * @param {boolean} hasHooks Whether the emitted hooks.json registers anything.
+ */
+function writeHookScripts(outDir, hasHooks) {
+  const hooksDir = path.join(outDir, "hooks");
+  if (fs.existsSync(hooksDir)) {
+    const scripts = fs
+      .readdirSync(hooksDir, { withFileTypes: true })
+      .filter(e => e.isFile() && e.name.endsWith(".sh"))
+      .map(e => e.name);
+    const keep = new Set(filterScriptsForAgent(scripts, "devin"));
+    for (const name of scripts) {
+      if (!keep.has(name)) fs.rmSync(path.join(hooksDir, name));
+    }
+  }
+  if (hasHooks) {
+    fs.mkdirSync(hooksDir, { recursive: true });
+    const shimPath = path.join(hooksDir, DEVIN_TOOL_SHIM);
+    fs.writeFileSync(shimPath, DEVIN_TOOL_SHIM_SOURCE);
+    fs.chmodSync(shimPath, 0o755);
+  }
+  if (fs.existsSync(hooksDir) && fs.readdirSync(hooksDir).length === 0) {
+    fs.rmdirSync(hooksDir);
+  }
+}
+
+/**
+ * Generate the Devin variant.
+ *
+ * @param {string} srcDir Built Claude plugin directory (input).
+ * @param {string} outDir Devin variant output directory.
+ * @param {string} version Version string for the manifests.
+ * @returns {boolean} True when a variant was written; false (and nothing
+ *   written) when the source has no Claude manifest.
+ */
+export function generateDevinVariant(srcDir, outDir, version) {
+  const claudeManifestPath = path.join(srcDir, ".claude-plugin", PLUGIN_JSON);
+  if (!fs.existsSync(claudeManifestPath)) return false;
+
+  fs.rmSync(outDir, { recursive: true, force: true });
+  copyDir(srcDir, outDir, keepForDevin);
+  pruneEmptySkillAgentDirs(outDir);
+
+  const claudeManifest = JSON.parse(
+    fs.readFileSync(claudeManifestPath, "utf8")
+  );
+  const hooksJson = buildDevinHooksJson(claudeManifest.hooks ?? {});
+
+  // Native Devin manifest: metadata only. Skills, agents and the root
+  // `.mcp.json` are discovered from their default locations.
+  const devinManifest = Object.fromEntries(
+    DEVIN_MANIFEST_FIELDS.filter(key => claudeManifest[key] !== undefined).map(
+      key => [key, claudeManifest[key]]
+    )
+  );
+  devinManifest.version = version;
+  fs.mkdirSync(path.join(outDir, ".devin-plugin"), { recursive: true });
+  fs.writeFileSync(
+    path.join(outDir, ".devin-plugin", PLUGIN_JSON),
+    `${JSON.stringify(devinManifest, null, 2)}\n`
+  );
+
+  // The Claude manifest stays for marketplace tooling, minus its hooks: Devin
+  // ignores them, and leaving Claude-matcher hooks in a Devin artifact would
+  // read as coverage that does not exist.
+  const claudeCopy = { ...claudeManifest, version };
+  delete claudeCopy.hooks;
+  fs.writeFileSync(
+    path.join(outDir, ".claude-plugin", PLUGIN_JSON),
+    `${JSON.stringify(claudeCopy, null, 2)}\n`
+  );
+
+  const rootHooksPath = path.join(outDir, "hooks.json");
+  if (hooksJson) {
+    fs.writeFileSync(rootHooksPath, `${JSON.stringify(hooksJson, null, 2)}\n`);
+  } else {
+    fs.rmSync(rootHooksPath, { force: true });
+  }
+  writeHookScripts(outDir, Boolean(hooksJson));
+  rewritePluginRuleCitations(outDir, "devin");
+  return true;
+}
+
+// CLI entrypoint.
+if (invokedAsScript(import.meta.url)) {
+  const [srcDir, outDir, version] = process.argv.slice(2);
+  if (!srcDir || !outDir || !version) {
+    console.error(
+      "Usage: generate-devin-plugin-artifacts.mjs <src> <out> <version>"
+    );
+    process.exit(1);
+  }
+  if (!generateDevinVariant(srcDir, outDir, version)) {
+    console.error(
+      `No .claude-plugin/plugin.json under ${srcDir}; no Devin variant generated`
+    );
+    process.exit(1);
+  }
+  console.log(`Generated Devin variant at ${outDir} (v${version})`);
+}

package/scripts/lib/hook-registration-audit.mjs

@@ -56,6 +56,7 @@ const SHIP_LIST_AGENTS = Object.freeze([
   "cursor",
   "agy",
   "copilot",
+  "devin",
 ]);
 
 /** Filenames a coding agent reads hook registrations out of. */
@@ -200,12 +201,13 @@ export function readManifestSurfaces(root, hookNames) {
  *
  * @param {string} portName
  * @param {string} manifestRelPath
- * @returns {"agy"|"cursor"|"copilot"|"codex"|"claude"}
+ * @returns {"agy"|"cursor"|"copilot"|"devin"|"codex"|"claude"}
  */
 export function surfaceAgent(portName, manifestRelPath) {
   if (portName.endsWith(AGY_PORT_SUFFIX)) return "agy";
   if (portName.endsWith("-cursor")) return "cursor";
   if (portName.endsWith("-copilot")) return "copilot";
+  if (portName.endsWith("-devin")) return "devin";
   if (manifestRelPath.split(path.sep).includes(".codex-plugin")) return "codex";
   return "claude";
 }