@openclaw/plugin-inspector 0.2.0 → 0.3.1

package/src/cli.js

@@ -72,8 +72,17 @@ async function runCheck(commandArgs) {
   const json = commandArgs.includes("--json");
   const capture = readRuntimeFlag(commandArgs);
   const mockSdk = readMockSdkFlag(commandArgs);
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs);
-  const { report, paths } = await runPluginCheck({ configPath, pluginRoot, outDir, openclawPath, capture, mockSdk });
+  const { report, paths } = await runPluginCheck({
+    allowExecution,
+    capture,
+    configPath,
+    mockSdk,
+    openclawPath,
+    outDir,
+    pluginRoot,
+  });
   await writeCiOutputArtifacts(report, {
     ...ciOutputs,
     cwd: path.dirname(paths.jsonPath),
@@ -83,7 +92,7 @@ async function runCheck(commandArgs) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    console.log(renderTextSummary(report));
+    console.log(renderTextSummary(report, { artifacts: paths }));
   }
 
   if (report.status !== "pass") {
@@ -95,19 +104,27 @@ async function runInit(commandArgs) {
   const pluginRoot = readFlag(commandArgs, "--plugin-root") ?? readFlag(commandArgs, "--root");
   const configPath = readFlag(commandArgs, "--config") ?? undefined;
   const workflowPath = readFlag(commandArgs, "--workflow") ?? undefined;
-  const packageManager = readFlag(commandArgs, "--package-manager") ?? "npm";
+  const packageManager = readFlag(commandArgs, "--package-manager") ?? undefined;
   const result = await writePluginInspectorInit({
     pluginRoot,
     configPath,
     workflowPath,
     packageManager,
     ci: commandArgs.includes("--ci"),
+    dryRun: commandArgs.includes("--dry-run"),
+    scripts: commandArgs.includes("--scripts"),
     force: commandArgs.includes("--force"),
   });
 
+  if (commandArgs.includes("--json")) {
+    console.log(JSON.stringify(initCommandSummary(result), null, 2));
+    return;
+  }
+
   for (const filePath of result.written) {
-    console.log(`wrote ${filePath}`);
+    console.log(`${result.dryRun ? "would write" : "wrote"} ${path.relative(result.pluginRoot, filePath)}`);
   }
+  console.log(`package manager: ${result.packageManager}`);
 }
 
 async function runReport(command, commandArgs) {
@@ -128,7 +145,7 @@ async function runReport(command, commandArgs) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    console.log(renderTextSummary(report));
+    console.log(renderTextSummary(report, { artifacts: paths }));
   }
 
   if (check && report.status !== "pass") {
@@ -144,8 +161,10 @@ async function runCi(commandArgs) {
   const json = commandArgs.includes("--json");
   const capture = readRuntimeFlag(commandArgs);
   const mockSdk = readMockSdkFlag(commandArgs);
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   const ciOutputs = readCiOutputFlags(commandArgs, { defaultEnabled: true });
   const { report, reportDir } = await runCiCompatibilityReport({
+    allowExecution,
     capture,
     configPath,
     mockSdk,
@@ -184,7 +203,7 @@ async function runCi(commandArgs) {
   }
 }
 
-async function runCiCompatibilityReport({ capture, configPath, mockSdk, openclawPath, outDir, pluginRoot }) {
+async function runCiCompatibilityReport({ allowExecution, capture, configPath, mockSdk, openclawPath, outDir, pluginRoot }) {
   if (configPath) {
     const config = await loadInspectorConfig(configPath, { cwd: pluginRoot });
     const report = await inspectCompatibilityFixtureSet(config, { openclawPath });
@@ -195,7 +214,7 @@ async function runCiCompatibilityReport({ capture, configPath, mockSdk, openclaw
     };
   }
 
-  const { report } = await runPluginCheck({ pluginRoot, outDir, openclawPath, capture, mockSdk });
+  const { report } = await runPluginCheck({ allowExecution, capture, mockSdk, openclawPath, outDir, pluginRoot });
   return {
     report,
     reportDir: path.resolve(pluginRoot ?? process.cwd(), outDir),
@@ -207,11 +226,12 @@ async function runCapture(commandArgs) {
   const outputPath = readFlag(commandArgs, "--output");
   const pluginRoot = readFlag(commandArgs, "--plugin-root");
   const mockSdk = readMockSdkFlag(commandArgs) ?? commandArgs.includes("--mock-sdk");
+  const allowExecution = readAllowExecutionFlag(commandArgs);
   if (!entrypoint) {
     throw new Error("capture requires an entrypoint path");
   }
-  if (process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED !== "1") {
-    throw new Error("capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 in an isolated workspace");
+  if (!allowExecution && process.env.PLUGIN_INSPECTOR_EXECUTE_ISOLATED !== "1") {
+    throw new Error("capture imports plugin code; rerun with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 or --allow-execute in an isolated workspace");
   }
 
   const result = await captureEntrypoint(entrypoint, { mockSdk, pluginRoot });
@@ -281,6 +301,10 @@ function readMockSdkFlag(commandArgs) {
   return undefined;
 }
 
+function readAllowExecutionFlag(commandArgs) {
+  return commandArgs.includes("--allow-execute");
+}
+
 function renderCiTextSummary(summary) {
   return [
     `Status: ${summary.status.toUpperCase()}`,
@@ -290,6 +314,15 @@ function renderCiTextSummary(summary) {
   ].join("\n");
 }
 
+function initCommandSummary(result) {
+  return {
+    dryRun: result.dryRun,
+    packageManager: result.packageManager,
+    pluginRoot: result.pluginRoot,
+    files: result.written.map((filePath) => path.relative(result.pluginRoot, filePath)),
+  };
+}
+
 function renderConfigTextSummary(config) {
   const fixture = config.fixtures[0];
   return [
@@ -308,16 +341,16 @@ function printHelp() {
 
 Usage:
   plugin-inspector
-  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--json]
+  plugin-inspector check [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json]
   plugin-inspector config [--plugin-root <path>] [--config <path>] [--json]
-  plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--package-manager npm|pnpm|yarn|bun] [--force]
+  plugin-inspector init [--plugin-root <path>] [--config <path>] [--ci] [--scripts] [--package-manager npm|pnpm|yarn|bun] [--dry-run] [--json] [--force]
   plugin-inspector report --config <path> [--out <dir>] [--check] [--json]
-  plugin-inspector inspect [--plugin-root <path>] [--config <path>] [--out <dir>] [--check] [--json] [--sarif [path]] [--junit [path]]
-  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--json] [--no-sarif] [--no-junit]
-  PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--plugin-root <path>] [--output <path>]
+  plugin-inspector inspect [--plugin-root <path>] [--config <path>] [--out <dir>] [--check] [--json] [--sarif [path]] [--junit [path]] [--allow-execute]
+  plugin-inspector ci [--plugin-root <path>] [--config <path>] [--out <dir>] [--openclaw <path>] [--no-openclaw] [--runtime] [--mock-sdk|--real-sdk] [--allow-execute] [--json] [--no-sarif] [--no-junit]
+  plugin-inspector capture <entrypoint> [--mock-sdk|--real-sdk] [--allow-execute] [--plugin-root <path>] [--output <path>]
 
 Default check runs from the current plugin root and writes reports/ unless --out is set.
 CI writes SARIF and JUnit artifacts by default; check/inspect can write them with --sarif and --junit.
-Runtime capture is opt-in because it imports plugin code; use --runtime with PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
+Runtime capture is opt-in because it imports plugin code; use --runtime with --allow-execute or PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1.
 `);
 }

package/src/index.js

@@ -1,12 +1,239 @@
+import * as pluginApi from "./api.js";
+import * as ciPolicyApi from "./ci-policy.js";
+import * as ciSummaryApi from "./ci-summary.js";
+import * as configApi from "./config.js";
+import * as contractCaptureApi from "./contract-capture.js";
+import * as contractCoverageApi from "./contract-coverage.js";
+import * as executionResultsApi from "./execution-results.js";
+import * as importLoopProfileApi from "./import-loop-profile.js";
+import * as inspectorApi from "./inspector.js";
+import * as issuesApi from "./issues.js";
+import * as openClawTargetApi from "./openclaw-target.js";
+import * as profileDiffApi from "./profile-diff.js";
+import * as refDiffApi from "./ref-diff.js";
+import * as reportApi from "./report.js";
+import * as runtimeProfileApi from "./runtime-profile.js";
+import * as syntheticProbeSuiteApi from "./synthetic-probe-suite.js";
+import * as syntheticProbesApi from "./synthetic-probes.js";
+
+export const pluginRoot = Object.freeze({
+  loadConfig: pluginApi.loadPluginConfig,
+  inspect: pluginApi.inspectPluginRoot,
+  runCheck: pluginApi.runPluginCheck,
+  captureEntrypoint: pluginApi.capturePluginEntrypoint,
+  setup: pluginApi.setupPluginInspector,
+});
+
+export const fixtureSuites = Object.freeze({
+  loadConfig: configApi.loadInspectorConfig,
+  inspect: pluginApi.inspectCompatibilityFixtureSetConfig,
+  inspectStatic: pluginApi.inspectFixtureSetConfig,
+  runReport: pluginApi.runFixtureSetReport,
+  writeReports: pluginApi.writeFixtureSetReports,
+  renderReport: pluginApi.renderFixtureSetMarkdownReport,
+  renderIssues: pluginApi.renderFixtureSetIssuesReport,
+  buildColdImportReadiness: pluginApi.buildFixtureSetColdImportReadiness,
+  runColdImportReadiness: pluginApi.runFixtureSetColdImportReadiness,
+  writeColdImportReadiness: pluginApi.writeFixtureSetColdImportReadiness,
+  buildWorkspacePlan: pluginApi.buildFixtureSetWorkspacePlan,
+  runWorkspacePlan: pluginApi.runFixtureSetWorkspacePlan,
+  writeWorkspacePlan: pluginApi.writeFixtureSetWorkspacePlan,
+  buildPlatformProbes: pluginApi.buildFixtureSetPlatformProbes,
+  runPlatformProbes: pluginApi.runFixtureSetPlatformProbes,
+  writePlatformProbes: pluginApi.writeFixtureSetPlatformProbes,
+});
+
+export const staticInspection = Object.freeze({
+  loadConfig: configApi.loadInspectorConfig,
+  inspectSourceText: inspectorApi.inspectSourceText,
+  inspectPlugin: inspectorApi.inspectPlugin,
+  inspectFixtureSet: inspectorApi.inspectFixtureSet,
+});
+
+export const reports = Object.freeze({
+  renderMarkdown: reportApi.renderMarkdownReport,
+  renderTextSummary: pluginApi.renderTextSummary,
+  write: reportApi.writeReport,
+  issueId: issuesApi.issueId,
+  classifyIssueFinding: issuesApi.classifyIssueFinding,
+  knownIssueCodes: issuesApi.knownIssueCodes,
+  openClawTargetPathCandidates: openClawTargetApi.openClawTargetPathCandidates,
+});
+
+export const contracts = Object.freeze({
+  buildCapture: contractCaptureApi.buildContractCapture,
+  writeCapture: contractCaptureApi.writeContractCapture,
+  renderCapture: contractCaptureApi.renderContractCaptureMarkdown,
+  validateCapture: contractCaptureApi.validateContractCapture,
+  validateCoverage: contractCoverageApi.validateContractCoverage,
+  defaults: Object.freeze({
+    registrationAssertions: contractCaptureApi.defaultRegistrationAssertions,
+    registrationArguments: contractCaptureApi.defaultRegistrationArguments,
+    hookAssertions: contractCaptureApi.defaultHookAssertions,
+    hookEvents: contractCaptureApi.defaultHookEvents,
+    hookContexts: contractCaptureApi.defaultHookContexts,
+  }),
+});
+
+export const ci = Object.freeze({
+  buildSummary: ciSummaryApi.buildCiSummary,
+  writeSummary: ciSummaryApi.writeCiSummary,
+  renderSummary: ciSummaryApi.renderCiSummaryMarkdown,
+  readReports: ciSummaryApi.readCiReports,
+  deriveStatus: ciSummaryApi.deriveCiStatus,
+  buildPolicyReport: ciPolicyApi.buildCiPolicyReport,
+  writePolicyReport: ciPolicyApi.writeCiPolicyReport,
+  renderPolicyReport: ciPolicyApi.renderCiPolicyMarkdown,
+  validatePolicy: ciPolicyApi.validateCiPolicy,
+  validatePolicyReport: ciPolicyApi.validateCiPolicyReport,
+  buildExecutionResults: executionResultsApi.buildExecutionResultsReport,
+  writeExecutionResults: executionResultsApi.writeExecutionResultsReport,
+  renderExecutionResults: executionResultsApi.renderExecutionResultsMarkdown,
+  writeOutputs: pluginApi.writeCiOutputArtifacts,
+});
+
+export const runtime = Object.freeze({
+  buildProfile: runtimeProfileApi.buildRuntimeProfile,
+  writeProfile: runtimeProfileApi.writeRuntimeProfile,
+  renderProfile: runtimeProfileApi.renderRuntimeProfileMarkdown,
+  validateProfile: runtimeProfileApi.validateRuntimeProfile,
+  buildProfileDiff: profileDiffApi.buildProfileDiff,
+  writeProfileDiff: profileDiffApi.writeProfileDiff,
+  renderProfileDiff: profileDiffApi.renderProfileDiffMarkdown,
+  validateProfileDiff: profileDiffApi.validateProfileDiff,
+  buildRefDiff: refDiffApi.buildRefDiff,
+  writeRefDiff: refDiffApi.writeRefDiff,
+  renderRefDiff: refDiffApi.renderRefDiffMarkdown,
+  validateRefDiff: refDiffApi.validateRefDiff,
+  buildImportLoopProfile: importLoopProfileApi.buildImportLoopProfile,
+  writeImportLoopProfile: importLoopProfileApi.writeImportLoopProfile,
+  renderImportLoopProfile: importLoopProfileApi.renderImportLoopProfileMarkdown,
+  validateImportLoopProfile: importLoopProfileApi.validateImportLoopProfile,
+});
+
+export const synthetic = Object.freeze({
+  buildPlan: syntheticProbesApi.buildSyntheticProbePlan,
+  buildPlanFromReport: syntheticProbeSuiteApi.buildSyntheticProbePlanFromReport,
+  writePlan: syntheticProbesApi.writeSyntheticProbePlan,
+  renderPlan: syntheticProbesApi.renderSyntheticProbeMarkdown,
+  validatePlan: syntheticProbesApi.validateSyntheticProbePlan,
+  runCaptured: syntheticProbesApi.runCapturedSyntheticProbes,
+  registrationExecutionProfiles: syntheticProbesApi.syntheticRegistrationExecutionProfiles,
+  defaultHookEvents: syntheticProbesApi.defaultSyntheticHookEvents,
+  defaultHookContexts: syntheticProbesApi.defaultSyntheticHookContexts,
+  defaultRegistrationArguments: syntheticProbesApi.defaultSyntheticRegistrationArguments,
+});
+
 export {
   capturePluginEntrypoint,
+  buildFixtureSetColdImportReadiness,
+  buildFixtureSetPlatformProbes,
+  buildFixtureSetWorkspacePlan,
   createCaptureApi,
+  inspectCompatibilityFixtureSetConfig,
   inspectFixtureSetConfig,
   inspectPluginRoot,
   loadPluginConfig,
+  renderFixtureSetColdImportReadinessMarkdown,
+  renderFixtureSetIssuesReport,
+  renderFixtureSetMarkdownReport,
+  renderFixtureSetPlatformProbesMarkdown,
+  renderFixtureSetWorkspacePlanMarkdown,
   renderTextSummary,
+  runFixtureSetColdImportReadiness,
+  runFixtureSetPlatformProbes,
+  runFixtureSetReport,
+  runFixtureSetWorkspacePlan,
   runPluginCheck,
   setupPluginInspector,
+  validateColdImportReadiness,
+  validateFixtureSetPlatformProbes,
+  validateFixtureSetWorkspacePlan,
   writeCiOutputArtifacts,
+  writeFixtureSetColdImportReadiness,
+  writeFixtureSetPlatformProbes,
+  writeFixtureSetReports,
+  writeFixtureSetWorkspacePlan,
   writePluginReports,
 } from "./api.js";
+export {
+  buildContractCapture,
+  defaultHookAssertions,
+  defaultHookContexts,
+  defaultHookEvents,
+  defaultRegistrationArguments,
+  defaultRegistrationAssertions,
+  renderContractCaptureMarkdown,
+  validateContractCapture,
+  writeContractCapture,
+} from "./contract-capture.js";
+export { validateContractCoverage } from "./contract-coverage.js";
+export {
+  buildCiPolicyReport,
+  defaultCiPolicyReportOptions,
+  renderCiPolicyMarkdown,
+  validateCiPolicy,
+  validateCiPolicyReport,
+  writeCiPolicyReport,
+} from "./ci-policy.js";
+export {
+  buildCiSummary,
+  defaultCiReportPaths,
+  deriveCiStatus,
+  readCiReports,
+  renderCiSummaryMarkdown,
+  writeCiSummary,
+} from "./ci-summary.js";
+export { loadInspectorConfig } from "./config.js";
+export {
+  buildExecutionResultsReport,
+  defaultExecutionResultsOptions,
+  renderExecutionResultsMarkdown,
+  writeExecutionResultsReport,
+} from "./execution-results.js";
+export {
+  buildImportLoopProfile,
+  defaultImportLoopProfileOptions,
+  renderImportLoopProfileMarkdown,
+  validateImportLoopProfile,
+  writeImportLoopProfile,
+} from "./import-loop-profile.js";
+export { classifyIssueFinding, issueId, knownIssueCodes } from "./issues.js";
+export { inspectFixtureSet, inspectPlugin, inspectSourceText } from "./inspector.js";
+export { openClawTargetPathCandidates } from "./openclaw-target.js";
+export {
+  buildProfileDiff,
+  defaultProfileDiffOptions,
+  renderProfileDiffMarkdown,
+  validateProfileDiff,
+  writeProfileDiff,
+} from "./profile-diff.js";
+export {
+  buildRefDiff,
+  defaultRefDiffDimensions,
+  defaultRefDiffOptions,
+  renderRefDiffMarkdown,
+  validateRefDiff,
+  writeRefDiff,
+} from "./ref-diff.js";
+export { renderMarkdownReport, writeReport } from "./report.js";
+export {
+  buildRuntimeProfile,
+  defaultRuntimeProfileCommands,
+  defaultRuntimeProfileOptions,
+  renderRuntimeProfileMarkdown,
+  validateRuntimeProfile,
+  writeRuntimeProfile,
+} from "./runtime-profile.js";
+export { buildSyntheticProbePlanFromReport } from "./synthetic-probe-suite.js";
+export {
+  buildSyntheticProbePlan,
+  defaultSyntheticHookContexts,
+  defaultSyntheticHookEvents,
+  defaultSyntheticRegistrationArguments,
+  renderSyntheticProbeMarkdown,
+  runCapturedSyntheticProbes,
+  syntheticRegistrationExecutionProfiles,
+  validateSyntheticProbePlan,
+  writeSyntheticProbePlan,
+} from "./synthetic-probes.js";

package/src/init.js

@@ -5,32 +5,66 @@ import { inferPluginSeams, packageId } from "./config.js";
 
 export const defaultInitConfigPath = "plugin-inspector.config.json";
 export const defaultInitWorkflowPath = ".github/workflows/plugin-inspector.yml";
+export const defaultInitPackageScripts = {
+  "plugin:check": "plugin-inspector inspect --no-openclaw",
+  "plugin:ci": "plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute",
+};
 
 export async function writePluginInspectorInit(options = {}) {
   const pluginRoot = path.resolve(options.pluginRoot ?? options.cwd ?? process.cwd());
   const configPath = path.resolve(pluginRoot, options.configPath ?? defaultInitConfigPath);
+  const workflowPath = options.ci === true ? path.resolve(pluginRoot, options.workflowPath ?? defaultInitWorkflowPath) : null;
+  const packageManager = options.packageManager ?? (await detectPackageManager(pluginRoot));
+  const dryRun = options.dryRun === true;
   const written = [];
 
-  if (existsSync(configPath) && options.force !== true) {
+  if (!dryRun && existsSync(configPath) && options.force !== true) {
     throw new Error(`${path.relative(pluginRoot, configPath)} already exists; pass --force to overwrite it`);
   }
+  if (!dryRun && workflowPath && existsSync(workflowPath) && options.force !== true) {
+    throw new Error(`${path.relative(pluginRoot, workflowPath)} already exists; pass --force to overwrite it`);
+  }
+  const packageJsonPath = path.join(pluginRoot, "package.json");
+  const packageJson = options.scripts === true ? await readJsonIfExists(packageJsonPath) : null;
+  if (options.scripts === true) {
+    if (!packageJson) {
+      throw new Error("package.json is required to write plugin-inspector package scripts");
+    }
+    for (const name of Object.keys(defaultInitPackageScripts)) {
+      if (!dryRun && packageJson.scripts?.[name] && options.force !== true) {
+        throw new Error(`package.json scripts.${name} already exists; pass --force to overwrite it`);
+      }
+    }
+  }
 
   const config = await buildPluginInspectorConfig({ pluginRoot });
-  await mkdir(path.dirname(configPath), { recursive: true });
-  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  if (!dryRun) {
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  }
   written.push(configPath);
 
-  if (options.ci === true) {
-    const workflowPath = path.resolve(pluginRoot, options.workflowPath ?? defaultInitWorkflowPath);
-    if (existsSync(workflowPath) && options.force !== true) {
-      throw new Error(`${path.relative(pluginRoot, workflowPath)} already exists; pass --force to overwrite it`);
+  if (workflowPath) {
+    if (!dryRun) {
+      await mkdir(path.dirname(workflowPath), { recursive: true });
+      await writeFile(workflowPath, renderGithubActionsWorkflow({ packageManager }), "utf8");
     }
-    await mkdir(path.dirname(workflowPath), { recursive: true });
-    await writeFile(workflowPath, renderGithubActionsWorkflow({ packageManager: options.packageManager }), "utf8");
     written.push(workflowPath);
   }
 
-  return { pluginRoot, configPath, written };
+  if (options.scripts === true) {
+    const existingScripts = packageJson.scripts ?? {};
+    packageJson.scripts = {
+      ...existingScripts,
+      ...defaultInitPackageScripts,
+    };
+    if (!dryRun) {
+      await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+    }
+    written.push(packageJsonPath);
+  }
+
+  return { pluginRoot, configPath, dryRun, packageManager, written };
 }
 
 export async function buildPluginInspectorConfig(options = {}) {
@@ -79,7 +113,7 @@ jobs:
           node-version: 24
           cache: ${setup.cache}
 ${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.install}
-      - run: PLUGIN_INSPECTOR_EXECUTE_ISOLATED=1 ${setup.exec} @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk
+      - run: ${setup.exec} @openclaw/plugin-inspector ci --no-openclaw --runtime --mock-sdk --allow-execute
       - uses: actions/upload-artifact@v5
         if: always()
         with:
@@ -88,19 +122,62 @@ ${setup.corepack ? "      - run: corepack enable\n" : ""}      - run: ${setup.in
 `;
 }
 
+export async function detectPackageManager(pluginRoot) {
+  const root = path.resolve(pluginRoot ?? process.cwd());
+  const packageJson = await readJsonIfExists(path.join(root, "package.json"));
+  const packageManager = packageJson?.packageManager;
+  if (typeof packageManager === "string") {
+    const [name] = packageManager.split("@");
+    if (["npm", "pnpm", "yarn", "bun"].includes(name)) {
+      return name;
+    }
+  }
+
+  if (existsSync(path.join(root, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(path.join(root, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(path.join(root, "bun.lockb")) || existsSync(path.join(root, "bun.lock"))) {
+    return "bun";
+  }
+  return "npm";
+}
+
 function inferSourceRoot(packageJson) {
   const entrypoints = [
     packageJson?.openclaw?.entrypoint,
     ...(packageJson?.openclaw?.extensions ?? []),
     ...(packageJson?.openclaw?.runtimeExtensions ?? []),
+    ...entrypointStrings(packageJson?.exports?.["."]),
+    ...entrypointStrings(packageJson?.exports),
+    packageJson?.module,
+    packageJson?.main,
   ].filter((value) => typeof value === "string");
-  const entrypoint = entrypoints[0] ?? packageJson?.exports?.["."] ?? packageJson?.main ?? "src/index.js";
-  if (typeof entrypoint === "string" && entrypoint.startsWith("src/")) {
+  const entrypoint = entrypoints[0] ?? "src/index.js";
+  if (stripRelativePrefix(entrypoint).startsWith("src/")) {
     return "src";
   }
   return ".";
 }
 
+function entrypointStrings(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return [];
+  }
+  return ["import", "default", "require", "node", "module"]
+    .map((key) => value[key])
+    .filter((item) => typeof item === "string");
+}
+
+function stripRelativePrefix(filePath) {
+  return filePath.replace(/^\.\//, "");
+}
+
 async function readJsonIfExists(filePath) {
   if (!existsSync(filePath)) {
     return null;

package/src/mock-sdk-capture-runner.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { mkdtemp, rm } from "node:fs/promises";
+import { rmSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
 import { register } from "node:module";
 import os from "node:os";
 import path from "node:path";
@@ -26,13 +27,16 @@ async function run(options) {
   const pluginRoot = path.resolve(options.cwd ?? process.cwd(), options.pluginRoot ?? path.dirname(entrypoint));
   const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-mock-sdk-"));
 
-  try {
-    const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-    register(pathToFileURL(loaderPath));
-    return await captureLinkedEntrypoint(entrypoint, options);
-  } finally {
-    await rm(workspace, { force: true, recursive: true });
-  }
+  cleanupTempDirOnExit(workspace);
+  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
+  register(pathToFileURL(loaderPath));
+  return await captureLinkedEntrypoint(entrypoint, options);
+}
+
+function cleanupTempDirOnExit(dir) {
+  process.once("exit", () => {
+    rmSync(dir, { force: true, recursive: true });
+  });
 }
 
 async function captureLinkedEntrypoint(entrypoint, options) {

package/src/report.js

@@ -246,27 +246,79 @@ export async function writeReport(report, options = {}) {
 export async function writeCompatibilityReport(report, options = {}) {
   const outDir = path.resolve(options.cwd ?? process.cwd(), options.outDir ?? "reports");
   const basename = options.basename ?? "plugin-inspector-report";
-  const jsonPath = path.join(outDir, `${basename}.json`);
-  const markdownPath = path.join(outDir, `${basename}.md`);
-  const issuesPath = path.join(outDir, options.issuesBasename ?? "plugin-inspector-issues.md");
+  const jsonPath = options.jsonPath ?? path.join(outDir, `${basename}.json`);
+  const markdownPath = options.markdownPath ?? path.join(outDir, `${basename}.md`);
+  const issuesPath = options.issuesPath ?? path.join(outDir, options.issuesBasename ?? "plugin-inspector-issues.md");
+  const markdownOptions = compatibilityRenderOptions(options, {
+    title: options.markdownTitle ?? options.title,
+    ...options.markdownOptions,
+  });
+  const issuesOptions = compatibilityRenderOptions(options, {
+    title: options.issuesTitle ?? options.title,
+    ...options.issuesOptions,
+  });
 
   return writeArtifacts(
     [
       { name: "jsonPath", path: jsonPath, json: report },
-      { name: "markdownPath", path: markdownPath, markdown: renderCompatibilityMarkdownReport(report) },
-      { name: "issuesPath", path: issuesPath, markdown: renderCompatibilityIssuesReport(report) },
+      { name: "markdownPath", path: markdownPath, markdown: renderCompatibilityMarkdownReport(report, markdownOptions) },
+      { name: "issuesPath", path: issuesPath, markdown: renderCompatibilityIssuesReport(report, issuesOptions) },
     ],
     { check: options.check },
   );
 }
 
-export function renderTextSummary(report) {
-  return [
+function compatibilityRenderOptions(options, overrides) {
+  const renderOptions = {
+    formatEvidence: options.formatEvidence,
+    severityLabels: options.severityLabels,
+    ...overrides,
+  };
+  return Object.fromEntries(Object.entries(renderOptions).filter(([, value]) => value !== undefined));
+}
+
+export function renderTextSummary(report, options = {}) {
+  const lines = [
     `Status: ${report.status.toUpperCase()}`,
     `Fixtures: ${report.summary.fixtureCount}`,
     `Breakages: ${report.summary.breakageCount}`,
+    ...(typeof report.summary.issueCount === "number" ? [`Issues: ${report.summary.issueCount}`] : []),
     `Logs: ${report.summary.logCount}`,
-  ].join("\n");
+  ];
+  const artifacts = Object.entries(options.artifacts ?? {}).filter(([, filePath]) => Boolean(filePath));
+  if (artifacts.length > 0) {
+    lines.push("", "Reports:", ...artifacts.map(([name, filePath]) => `- ${artifactLabel(name)}: ${filePath}`));
+  }
+  const findings = topTextFindings(report, options.topFindings ?? 3);
+  if (findings.length > 0) {
+    lines.push("", "Top findings:", ...findings.map((finding) => `- ${finding}`));
+  }
+  return lines.join("\n");
+}
+
+function topTextFindings(report, limit) {
+  if (report.status === "pass" || limit <= 0) {
+    return [];
+  }
+  return [
+    ...(report.breakages ?? []).map((finding) => formatTextFinding(finding, "breakage")),
+    ...(report.issues ?? [])
+      .filter((issue) => issue.status === "blocking" || issue.severity === "P0" || issue.severity === "P1")
+      .map((issue) => formatTextFinding(issue, issue.severity ?? "issue")),
+    ...(report.warnings ?? []).map((finding) => formatTextFinding(finding, "warning")),
+  ].slice(0, limit);
+}
+
+function formatTextFinding(finding, fallbackLevel) {
+  const level = finding.level ?? finding.severity ?? fallbackLevel;
+  const code = finding.code ? ` ${finding.code}` : "";
+  const message = finding.message ?? finding.title ?? "see report";
+  const evidence = Array.isArray(finding.evidence) && finding.evidence.length > 0 ? ` (${finding.evidence[0]})` : "";
+  return `${String(level).toUpperCase()} ${finding.fixture ?? "unknown"}${code}: ${message}${evidence}`;
+}
+
+function artifactLabel(name) {
+  return String(name).replace(/Path$/u, "");
 }
 
 export function renderMarkdownReport(report) {