@inspecto-dev/cli 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @inspecto-dev/cli
 
+## 0.3.2
+
+### Patch Changes
+
+- - feat: migrate all 7 integrations to Native Agent Skills
+  - feat: add automated onboarding experience via URI schemes
+  - refactor: use shared capabilities strategy for tool detection
+  - docs: synchronize english and chinese documentation
+  - fix: update travis and action test configurations
+- Updated dependencies
+  - @inspecto-dev/types@0.3.2
+
+## 0.3.1
+
+### Patch Changes
+
+- fix: polish onboarding and architecture visualization
+- Updated dependencies
+  - @inspecto-dev/types@0.3.1
+
 ## 0.3.0
 
 ### Minor Changes

package/README.md

@@ -7,19 +7,26 @@ The official command-line interface for Inspecto. This tool automates the proces
 For most users, the preferred setup path is assistant-first onboarding via the integrations documented in:
 `packages/docs/integrations/onboarding-skills.md`
 
-Install those assistant integration assets with:
+Run the install command for your assistant from the target project root:
 
 ```bash
-npx @inspecto-dev/cli integrations install <assistant>
+npx @inspecto-dev/cli integrations install codex --host-ide vscode
+npx @inspecto-dev/cli integrations install claude-code --scope project --host-ide vscode
+npx @inspecto-dev/cli integrations install copilot --host-ide vscode
+npx @inspecto-dev/cli integrations install cursor --host-ide cursor
+npx @inspecto-dev/cli integrations install gemini --host-ide vscode
+npx @inspecto-dev/cli integrations install trae --host-ide trae-cn
+npx @inspecto-dev/cli integrations install coco --host-ide trae-cn
 ```
 
 Supported assistants currently include `codex`, `claude-code`, `copilot`, `cursor`, `gemini`, `trae`, and `coco`.
 
+`--host-ide` values: `vscode`, `cursor`, `trae`, `trae-cn`.
+
 Inspect available integration targets with:
 
 ```bash
 npx @inspecto-dev/cli integrations list
-npx @inspecto-dev/cli integrations install codex
 npx @inspecto-dev/cli integrations path <assistant>
 ```
 
@@ -93,10 +100,123 @@ Manages assistant integration assets for the current project.
 Examples:
 
 ```bash
-inspecto integrations install codex
+inspecto integrations install codex --host-ide vscode
 inspecto integrations path codex
-inspecto integrations install claude-code --scope project
-inspecto integrations install cursor --mode rules
+inspecto integrations install claude-code --scope project --host-ide vscode
+inspecto integrations install cursor --host-ide cursor
+```
+
+#### `inspecto integrations doctor`
+
+Runs integration preflight checks for a selected assistant without writing files, installing extensions, opening IDE windows, or launching onboarding.
+
+Examples:
+
+```bash
+inspecto integrations doctor codex --host-ide cursor
+inspecto integrations doctor gemini --host-ide trae-cn --compact
+inspecto integrations doctor codex --host-ide cursor --json
+```
+
+Use `--compact` when you want a shorter human-readable summary. Use `--json` when the result will be consumed by tooling or CI.
+
+Recommended workflow:
+
+1. Run `inspecto integrations install <assistant> --host-ide <ide>` from the target project root.
+2. Use `inspecto integrations doctor <assistant> --host-ide <ide> --compact` only when you want to check blockers before install.
+3. Use `--json` instead of `--compact` when the result is consumed by scripts or CI.
+
+##### JSON contract
+
+`inspecto integrations doctor <assistant> --json` prints a single JSON object with this shape:
+
+```json
+{
+  "schemaVersion": "1",
+  "status": "ok",
+  "assistant": "codex",
+  "assets": [".agents/skills/inspecto-onboarding-codex/SKILL.md"],
+  "message": "Preview complete. Inspecto did not write files or open IDE windows. Review the resolved setup below, then rerun without --preview to apply it.",
+  "nextStep": "Run the same command again without --preview to apply the integration and launch onboarding.",
+  "automation": {
+    "status": "preview",
+    "message": "Preview complete. Inspecto did not write files or open IDE windows. Review the resolved setup below, then rerun without --preview to apply it.",
+    "nextStep": "Run the same command again without --preview to apply the integration and launch onboarding.",
+    "details": {
+      "hostIde": {
+        "id": "cursor",
+        "label": "Cursor",
+        "source": "from --host-ide",
+        "confidence": "high",
+        "candidates": ["cursor"]
+      },
+      "inspectoExtension": {
+        "source": "marketplace",
+        "reference": "inspecto.inspecto",
+        "binaryAvailable": true,
+        "binaryPath": "cursor",
+        "status": "preview_ready"
+      },
+      "runtime": {
+        "assistant": "Codex",
+        "ready": true,
+        "mode": "cli"
+      },
+      "workspace": {
+        "path": "/repo",
+        "attempted": true
+      },
+      "onboarding": {
+        "uri": "cursor://inspecto.inspecto/send?...",
+        "autoSend": true
+      }
+    }
+  }
+}
+```
+
+Top-level fields:
+
+- `schemaVersion`: Contract version for `inspecto integrations doctor --json`. The current documented value is `1`.
+- `status`: `ok` or `blocked`. This is the field most callers should branch on.
+- `assistant`: The requested integration target.
+- `assets`: The integration files that `inspecto integrations install <assistant>` would write.
+- `message`: Human-readable summary of the preflight result.
+- `nextStep`: Present when the flow is blocked or when there is a recommended follow-up action.
+- `automation`: The underlying preflight result from the IDE/runtime automation layer.
+
+`automation.status` values:
+
+- `preview`: Preflight succeeded. The flow is runnable.
+- `preview_blocked`: Preflight found blocking issues before launch.
+- `blocked`: Host IDE resolution failed before preflight could complete.
+
+`automation.details` fields:
+
+- `hostIde`: Resolved host IDE, confidence, resolution source, and alternative candidates.
+- `inspectoExtension`: How Inspecto would be installed into the host IDE.
+  `source` is `marketplace` or `local_vsix`.
+  `status` is one of:
+  `preview_ready`, `missing_host_ide_binary`, `missing_local_vsix`.
+- `runtime`: Resolved assistant runtime.
+  `mode` is the selected runtime mode such as `extension` or `cli`.
+  `ready=false` means the assistant cannot run yet in the chosen host IDE.
+- `workspace`: Target workspace routing information.
+- `onboarding`: Final onboarding URI and whether `autoSend` would be requested.
+
+##### Exit codes
+
+- Exit code `0`: `status=ok`
+- Exit code `1`: `status=blocked`
+
+This makes `inspecto integrations doctor` safe to use directly in CI and shell conditionals:
+
+```bash
+if inspecto integrations doctor codex --host-ide cursor --json; then
+  echo "integration is runnable"
+else
+  echo "integration is blocked"
+fi
 ```
 
 ### `inspecto doctor`

package/dist/bin.js

@@ -2,369 +2,25 @@ import {
   apply,
   detect,
   doctor,
-  exists,
   init,
-  log,
+  installIntegration,
+  integrationDoctor,
   onboard,
   plan,
+  printIntegrationList,
+  printIntegrationPath,
   reportCommandError,
-  teardown,
-  writeFile
-} from "./chunk-IBYH7QZM.js";
+  teardown
+} from "./chunk-LJOKPCPD.js";
 
 // src/bin.ts
 import { cac } from "cac";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire } from "module";
-
-// src/commands/integration-install.ts
-import fs from "fs/promises";
-import { homedir } from "os";
-import path from "path";
 import { fileURLToPath } from "url";
-var REPO_RAW_BASE = "https://raw.githubusercontent.com/inspecto-dev/inspecto/main";
-var INTEGRATION_MANIFESTS = [
-  {
-    assistant: "codex",
-    type: "native-skill",
-    installTarget: "~/.codex/skills/",
-    preferredInstall: "npx @inspecto-dev/cli integrations install codex",
-    cliSupported: true
-  },
-  {
-    assistant: "claude-code",
-    type: "native-skill",
-    installTarget: ".claude/skills/ or ~/.claude/skills/",
-    preferredInstall: "npx @inspecto-dev/cli integrations install claude-code --scope project",
-    cliSupported: true
-  },
-  {
-    assistant: "copilot",
-    type: "instruction-template",
-    installTarget: ".github/copilot-instructions.md or AGENTS.md",
-    preferredInstall: "npx @inspecto-dev/cli integrations install copilot",
-    cliSupported: true
-  },
-  {
-    assistant: "cursor",
-    type: "rule-template",
-    installTarget: ".cursor/rules/inspecto-onboarding.mdc or AGENTS.md",
-    preferredInstall: "npx @inspecto-dev/cli integrations install cursor --mode rules",
-    cliSupported: true
-  },
-  {
-    assistant: "gemini",
-    type: "context-template",
-    installTarget: "GEMINI.md",
-    preferredInstall: "npx @inspecto-dev/cli integrations install gemini",
-    cliSupported: true
-  },
-  {
-    assistant: "trae",
-    type: "compatibility-template",
-    installTarget: "AGENTS.md",
-    preferredInstall: "npx @inspecto-dev/cli integrations install trae",
-    cliSupported: true
-  },
-  {
-    assistant: "coco",
-    type: "compatibility-template",
-    installTarget: "AGENTS.md",
-    preferredInstall: "npx @inspecto-dev/cli integrations install coco",
-    cliSupported: true
-  }
-];
-async function installIntegration(assistant, options = {}) {
-  const plan2 = resolveInstallPlan(assistant, options);
-  log.header("Inspecto Integration Install");
-  for (const asset of plan2.assets) {
-    if (await exists(asset.target) && !options.force) {
-      throw new Error(
-        `Refusing to overwrite existing file: ${asset.target}. Re-run with --force if you want to replace it.`
-      );
-    }
-  }
-  const downloadedAssets = [];
-  for (const asset of plan2.assets) {
-    const content = await loadAsset(asset);
-    downloadedAssets.push({ asset, content });
-  }
-  for (const { asset, content } of downloadedAssets) {
-    await writeFile(asset.target, content);
-    if (asset.executable) {
-      await fs.chmod(asset.target, 493);
-    }
-  }
-  log.success(plan2.successMessage);
-  log.hint(plan2.nextStep);
-}
-function describeIntegration(assistant, options = {}) {
-  const manifest = getIntegrationManifest(assistant);
-  const targets = manifest.cliSupported ? resolveInstallPlan(assistant, options).assets.map((asset) => asset.target) : [manifest.installTarget];
-  return {
-    assistant: manifest.assistant,
-    type: manifest.type,
-    targets,
-    preferredInstall: manifest.preferredInstall,
-    cliSupported: manifest.cliSupported
-  };
-}
-function printIntegrationList() {
-  log.header("Inspecto Integrations");
-  for (const manifest of INTEGRATION_MANIFESTS) {
-    const support = manifest.cliSupported ? "CLI" : "native installer";
-    log.info(`${manifest.assistant} \u2014 ${manifest.type} \u2014 ${manifest.installTarget} \u2014 ${support}`);
-  }
-}
-function printIntegrationPath(assistant, options = {}) {
-  const description = describeIntegration(assistant, options);
-  log.header(`Inspecto Integration Paths: ${description.assistant}`);
-  for (const target of description.targets) {
-    log.info(target);
-  }
-  if (description.cliSupported) {
-    log.hint(`Preferred install: ${description.preferredInstall}`);
-  } else {
-    log.hint(`Native install required: ${description.preferredInstall}`);
-  }
-}
-function resolveInstallPlan(assistant, options) {
-  switch (assistant) {
-    case "codex":
-      return resolveCodexPlan(options);
-    case "claude-code":
-      return resolveClaudeCodePlan(options);
-    case "copilot":
-      return resolveCopilotPlan(options);
-    case "cursor":
-      return resolveCursorPlan(options);
-    case "gemini":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/gemini/GEMINI.md`,
-            target: "GEMINI.md",
-            localSource: "assistant-integrations/gemini/GEMINI.md"
-          }
-        ],
-        successMessage: "Installed Gemini context to GEMINI.md",
-        nextStep: "Start a new Gemini CLI session."
-      };
-    case "trae":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/trae/AGENTS.md`,
-            target: "AGENTS.md",
-            localSource: "assistant-integrations/trae/AGENTS.md"
-          }
-        ],
-        successMessage: "Installed Trae compatibility instructions to AGENTS.md",
-        nextStep: "Open a new Trae chat."
-      };
-    case "coco":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/coco/AGENTS.md`,
-            target: "AGENTS.md",
-            localSource: "assistant-integrations/coco/AGENTS.md"
-          }
-        ],
-        successMessage: "Installed Coco compatibility instructions to AGENTS.md",
-        nextStep: "Start a new Coco session."
-      };
-    default:
-      throw new Error(`Unknown assistant: ${assistant}`);
-  }
-}
-function getIntegrationManifest(assistant) {
-  const manifest = INTEGRATION_MANIFESTS.find((item) => item.assistant === assistant);
-  if (!manifest) {
-    throw new Error(
-      `Unknown assistant: ${assistant}. Run 'inspecto integrations list' to see available targets.`
-    );
-  }
-  return manifest;
-}
-function resolveCodexPlan(options) {
-  if (options.scope !== void 0) {
-    throw new Error("`--scope` is not supported for codex.");
-  }
-  if (options.mode !== void 0) {
-    throw new Error("`--mode` is not supported for codex.");
-  }
-  const baseDir = path.join(homedir(), ".codex/skills/inspecto-onboarding-codex");
-  return {
-    assets: [
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/SKILL.md`,
-        target: path.join(baseDir, "SKILL.md"),
-        localSource: "skills/inspecto-onboarding-codex/SKILL.md"
-      },
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/agents/openai.yaml`,
-        target: path.join(baseDir, "agents/openai.yaml"),
-        localSource: "skills/inspecto-onboarding-codex/agents/openai.yaml"
-      },
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-codex/scripts/run-inspecto.sh`,
-        target: path.join(baseDir, "scripts/run-inspecto.sh"),
-        executable: true,
-        localSource: "skills/inspecto-onboarding-codex/scripts/run-inspecto.sh"
-      }
-    ],
-    successMessage: `Installed Codex skill to ${baseDir}`,
-    nextStep: "Restart Codex or start a new Codex session to load the skill."
-  };
-}
-function resolveClaudeCodePlan(options) {
-  const scope = options.scope ?? "project";
-  const unsupportedMode = options.mode !== void 0;
-  if (unsupportedMode) {
-    throw new Error(
-      "`--mode` is not supported for claude-code. Use `--scope project|user` instead."
-    );
-  }
-  if (scope !== "project" && scope !== "user") {
-    throw new Error(`Unknown Claude Code scope: ${scope}`);
-  }
-  const baseDir = scope === "user" ? path.join(homedir(), ".claude/skills/inspecto-onboarding-claude-code") : ".claude/skills/inspecto-onboarding-claude-code";
-  return {
-    assets: [
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/SKILL.md`,
-        target: path.join(baseDir, "SKILL.md"),
-        localSource: "skills/inspecto-onboarding-claude-code/SKILL.md"
-      },
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/agents/openai.yaml`,
-        target: path.join(baseDir, "agents/openai.yaml"),
-        localSource: "skills/inspecto-onboarding-claude-code/agents/openai.yaml"
-      },
-      {
-        source: `${REPO_RAW_BASE}/skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh`,
-        target: path.join(baseDir, "scripts/run-inspecto.sh"),
-        executable: true,
-        localSource: "skills/inspecto-onboarding-claude-code/scripts/run-inspecto.sh"
-      }
-    ],
-    successMessage: `Installed Claude Code skill to ${baseDir}`,
-    nextStep: "Restart Claude Code to load the new skill."
-  };
-}
-function resolveCopilotPlan(options) {
-  const mode = options.mode ?? "instructions";
-  if (options.scope !== void 0) {
-    throw new Error(
-      "`--scope` is not supported for copilot. Use `--mode instructions|agents` instead."
-    );
-  }
-  switch (mode) {
-    case "instructions":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/copilot/.github/copilot-instructions.md`,
-            target: ".github/copilot-instructions.md",
-            localSource: "assistant-integrations/copilot/.github/copilot-instructions.md"
-          }
-        ],
-        successMessage: "Installed Copilot instructions to .github/copilot-instructions.md",
-        nextStep: "Open a new Copilot chat or agent session."
-      };
-    case "agents":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/copilot/AGENTS.md`,
-            target: "AGENTS.md",
-            localSource: "assistant-integrations/copilot/AGENTS.md"
-          }
-        ],
-        successMessage: "Installed Copilot compatibility instructions to AGENTS.md",
-        nextStep: "Open a new Copilot chat or agent session."
-      };
-    default:
-      throw new Error(`Unknown Copilot mode: ${mode}`);
-  }
-}
-function resolveCursorPlan(options) {
-  const mode = options.mode ?? "rules";
-  if (options.scope !== void 0) {
-    throw new Error("`--scope` is not supported for cursor. Use `--mode rules|agents` instead.");
-  }
-  switch (mode) {
-    case "rules":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/cursor/.cursor/rules/inspecto-onboarding.mdc`,
-            target: ".cursor/rules/inspecto-onboarding.mdc",
-            localSource: "assistant-integrations/cursor/.cursor/rules/inspecto-onboarding.mdc"
-          }
-        ],
-        successMessage: "Installed Cursor rule to .cursor/rules/inspecto-onboarding.mdc",
-        nextStep: "Open a new Cursor chat."
-      };
-    case "agents":
-      return {
-        assets: [
-          {
-            source: `${REPO_RAW_BASE}/assistant-integrations/cursor/AGENTS.md`,
-            target: "AGENTS.md",
-            localSource: "assistant-integrations/cursor/AGENTS.md"
-          }
-        ],
-        successMessage: "Installed Cursor compatibility instructions to AGENTS.md",
-        nextStep: "Open a new Cursor chat."
-      };
-    default:
-      throw new Error(`Unknown Cursor mode: ${mode}`);
-  }
-}
-async function loadAsset(asset) {
-  if (asset.localSource) {
-    const localPath = await resolveBundledAssetPath(asset.localSource);
-    if (localPath) {
-      return await fs.readFile(localPath, "utf-8");
-    }
-  }
-  return await downloadAsset(asset.source);
-}
-async function resolveBundledAssetPath(relativePath) {
-  const startDir = path.dirname(fileURLToPath(import.meta.url));
-  let currentDir = startDir;
-  for (let depth = 0; depth < 8; depth += 1) {
-    const candidate = path.join(currentDir, relativePath);
-    if (await exists(candidate)) {
-      return candidate;
-    }
-    const parent = path.dirname(currentDir);
-    if (parent === currentDir) break;
-    currentDir = parent;
-  }
-  return null;
-}
-async function downloadAsset(source) {
-  let response;
-  try {
-    response = await fetch(source);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to download ${source}: ${reason}`);
-  }
-  if (!response.ok) {
-    throw new Error(`Failed to download ${source}: ${response.status} ${response.statusText}`);
-  }
-  return await response.text();
-}
-
-// src/bin.ts
+import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var integrationScopes = ["project", "user"];
-var integrationModes = ["instructions", "agents", "rules"];
+var integrationModes = ["skills", "instructions", "agents", "rules"];
 function exitWithError(error, options = {}) {
   reportCommandError(error, {
     debug: options.debug ?? false,
@@ -449,20 +105,20 @@ function createCli(_argv = process.argv) {
       exitWithError(error, options);
     }
   });
-  cli.command("integrations [...args]", "Manage assistant integration assets").option(
+  cli.command("integrations [...args]", "Manage assistant integration assets").option("--json", "Print machine-readable JSON output", { default: false }).option(
     "--scope <scope>",
     "Set install scope for supported assistants (e.g. claude-code: project|user)"
   ).option(
     "--mode <mode>",
-    "Set install mode for supported assistants (e.g. copilot: instructions|agents)"
-  ).option("--force", "Overwrite existing integration files", { default: false }).option("--debug", "Enable debug mode to show full error traces", { default: false }).action(async (args, options) => {
+    "Set install mode for supported assistants (e.g. copilot: skills|instructions|agents)"
+  ).option("--host-ide <ide>", "Choose the host IDE for automatic extension install and launch").option("--inspecto-vsix <path>", "Install the Inspecto extension from a local .vsix path").option("--compact", "Print a shorter text summary for integration doctor").option("--preview", "Preview integration changes and IDE automation without executing them").option("--force", "Overwrite existing integration files", { default: false }).option("--debug", "Enable debug mode to show full error traces", { default: false }).action(async (args, options) => {
     try {
       const [subcommand, assistant, ...rest] = args;
       const integrationOptions = buildIntegrationOptions(options);
       if (subcommand === "list") {
-        if (assistant || rest.length > 0 || options.scope || options.mode || options.force) {
+        if (assistant || rest.length > 0 || options.scope || options.mode || options.hostIde || options.inspectoVsix || options.compact || options.json || options.preview || options.force) {
           throw new Error(
-            "The `list` subcommand does not accept assistant names, --scope, --mode, or --force."
+            "The `list` subcommand does not accept assistant names, --scope, --mode, --host-ide, --inspecto-vsix, --compact, --json, --preview, or --force."
           );
         }
         printIntegrationList();
@@ -475,16 +131,45 @@ function createCli(_argv = process.argv) {
         if (options.force) {
           throw new Error("The `path` subcommand does not support `--force`.");
         }
+        if (options.hostIde) {
+          throw new Error("The `path` subcommand does not support `--host-ide`.");
+        }
+        if (options.inspectoVsix) {
+          throw new Error("The `path` subcommand does not support `--inspecto-vsix`.");
+        }
+        if (options.preview) {
+          throw new Error("The `path` subcommand does not support `--preview`.");
+        }
+        if (options.compact) {
+          throw new Error("The `path` subcommand does not support `--compact`.");
+        }
+        if (options.json) {
+          throw new Error("The `path` subcommand does not support `--json`.");
+        }
         printIntegrationPath(assistant, integrationOptions);
         return;
       }
+      if (subcommand === "doctor" && assistant) {
+        if (rest.length > 0) {
+          throw new Error("The `doctor` subcommand accepts exactly one assistant argument.");
+        }
+        if (options.force) {
+          throw new Error("The `doctor` subcommand does not support `--force`.");
+        }
+        if (options.preview) {
+          throw new Error("The `doctor` subcommand does not support `--preview`.");
+        }
+        await integrationDoctor(assistant, { ...integrationOptions, failOnBlocked: true });
+        return;
+      }
       if (subcommand !== "install" || !assistant) {
         throw new Error(
           [
             "Usage:",
             "  inspecto integrations list",
             "  inspecto integrations path <assistant> [--scope <scope>] [--mode <mode>]",
-            "  inspecto integrations install <assistant> [--scope <scope>] [--mode <mode>] [--force]"
+            "  inspecto integrations doctor <assistant> [--scope <scope>] [--mode <mode>] [--host-ide <ide>] [--inspecto-vsix <path>] [--compact] [--json]",
+            "  inspecto integrations install <assistant> [--scope <scope>] [--mode <mode>] [--host-ide <ide>] [--inspecto-vsix <path>] [--preview] [--json] [--force]"
           ].join("\n")
         );
       }
@@ -519,6 +204,21 @@ function buildIntegrationOptions(options) {
       throw new Error(`Unknown integration mode: ${options.mode}`);
     }
   }
+  if (options.hostIde) {
+    resolved.ide = options.hostIde;
+  }
+  if (options.inspectoVsix) {
+    resolved.inspectoVsix = options.inspectoVsix;
+  }
+  if (options.compact) {
+    resolved.compact = options.compact;
+  }
+  if (options.preview) {
+    resolved.preview = options.preview;
+  }
+  if (options.json) {
+    resolved.json = options.json;
+  }
   return resolved;
 }
 function isIntegrationScope(value) {
@@ -537,7 +237,7 @@ async function runCli(argv = process.argv) {
   }
 }
 var entryPath = process.argv[1];
-if (entryPath && fileURLToPath2(import.meta.url) === entryPath) {
+if (entryPath && fileURLToPath(import.meta.url) === entryPath) {
   void runCli();
 }
 export {