@inspecto-dev/cli 0.3.1 → 0.3.3

package/dist/index.d.ts

@@ -245,6 +245,79 @@ interface DoctorCommandOptions {
 declare function collectDoctorResult(root?: string): Promise<DoctorResult>;
 declare function doctor(options?: DoctorCommandOptions | boolean): Promise<DoctorResult>;
 
+interface IntegrationAutomationOptions {
+    ide?: string;
+    inspectoVsix?: string;
+    preview?: boolean;
+    silent?: boolean;
+}
+interface IntegrationAutomationDetails {
+    hostIde?: {
+        id: string | null;
+        label?: string;
+        source?: string;
+        confidence: string;
+        candidates: string[];
+    };
+    inspectoExtension?: {
+        source: 'marketplace' | 'local_vsix';
+        reference: string;
+        binaryAvailable?: boolean;
+        binaryPath?: string | null;
+        status?: string;
+    };
+    runtime?: {
+        assistant: string;
+        ready: boolean;
+        mode: string | null;
+    };
+    workspace?: {
+        path?: string;
+        attempted: boolean;
+        opened?: boolean;
+    };
+    onboarding?: {
+        uri: string;
+        autoSend: boolean;
+    };
+}
+interface IntegrationAutomationResult {
+    status: 'launched' | 'partial' | 'blocked' | 'preview' | 'preview_blocked';
+    message: string;
+    nextStep?: string;
+    details?: IntegrationAutomationDetails;
+}
+declare function runIntegrationAutomation(assistant: string, options?: IntegrationAutomationOptions, cwd?: string): Promise<IntegrationAutomationResult>;
+
+type ClaudeScope = 'project' | 'user';
+type CopilotMode = 'skills' | 'instructions' | 'agents';
+type CursorMode = 'skills' | 'rules' | 'agents';
+interface InstallIntegrationOptions {
+    scope?: ClaudeScope;
+    mode?: CopilotMode | CursorMode;
+    force?: boolean;
+    ide?: string;
+    inspectoVsix?: string;
+    compact?: boolean;
+    preview?: boolean;
+    json?: boolean;
+}
+
+interface IntegrationDoctorOptions extends Pick<InstallIntegrationOptions, 'scope' | 'mode' | 'ide' | 'inspectoVsix' | 'json'> {
+    compact?: boolean;
+    failOnBlocked?: boolean;
+}
+interface IntegrationDoctorResult {
+    schemaVersion: string;
+    status: 'ok' | 'blocked';
+    assistant: string;
+    assets: string[];
+    message: string;
+    nextStep?: string;
+    automation: Awaited<ReturnType<typeof runIntegrationAutomation>>;
+}
+declare function integrationDoctor(assistant: string, options?: IntegrationDoctorOptions): Promise<IntegrationDoctorResult>;
+
 interface OnboardCommandOptions {
     json?: boolean;
     target?: string;
@@ -269,4 +342,4 @@ declare function reportCommandError(error: unknown, options?: ReportCommandError
 
 type Framework = 'react' | 'vue';
 
-export { type BuildTool, type DoctorDiagnostic, type DoctorResult, type Framework, type InitOptions, type InstallLock, type OnboardCommandResult, type OnboardStatus, type PackageManager, type ResolvedOnboardingSession, apply, collectDoctorResult, detect, doctor, init, onboard, plan, reportCommandError, teardown, writeCommandOutput };
+export { type BuildTool, type DoctorDiagnostic, type DoctorResult, type Framework, type InitOptions, type InstallLock, type OnboardCommandResult, type OnboardStatus, type PackageManager, type ResolvedOnboardingSession, apply, collectDoctorResult, detect, doctor, init, integrationDoctor, onboard, plan, reportCommandError, teardown, writeCommandOutput };

package/dist/index.js

@@ -4,18 +4,20 @@ import {
   detect,
   doctor,
   init,
+  integrationDoctor,
   onboard,
   plan,
   reportCommandError,
   teardown,
   writeCommandOutput
-} from "./chunk-PSYZB5GI.js";
+} from "./chunk-LJOKPCPD.js";
 export {
   apply,
   collectDoctorResult,
   detect,
   doctor,
   init,
+  integrationDoctor,
   onboard,
   plan,
   reportCommandError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspecto-dev/cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "CLI tools for Inspecto onboarding and lifecycle management",
   "keywords": [
     "inspecto",
@@ -20,7 +20,7 @@
     "ora": "^9.3.0",
     "picocolors": "^1.0.0",
     "prompts": "^2.4.2",
-    "@inspecto-dev/types": "0.3.1"
+    "@inspecto-dev/types": "0.3.3"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/bin.ts

@@ -19,6 +19,7 @@ import {
   printIntegrationList,
   printIntegrationPath,
 } from './commands/integration-install.js'
+import { integrationDoctor } from './commands/integration-doctor.js'
 import { reportCommandError } from './utils/output.js'
 
 const require = createRequire(import.meta.url)
@@ -58,14 +59,18 @@ interface OnboardCliOptions extends JsonCommandOptions {
   extension?: boolean
 }
 
-interface IntegrationCommandOptions extends GlobalOptions {
+interface IntegrationCommandOptions extends JsonCommandOptions {
   scope?: string
   mode?: string
+  hostIde?: string
+  inspectoVsix?: string
+  compact?: boolean
+  preview?: boolean
   force?: boolean
 }
 
 const integrationScopes = ['project', 'user'] as const
-const integrationModes = ['instructions', 'agents', 'rules'] as const
+const integrationModes = ['skills', 'instructions', 'agents', 'rules'] as const
 
 function exitWithError(error: unknown, options: JsonCommandOptions = {}): never {
   reportCommandError(error, {
@@ -205,14 +210,19 @@ export function createCli(_argv: readonly string[] = process.argv): CAC {
 
   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)',
+      '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: string[], options: IntegrationCommandOptions) => {
@@ -221,9 +231,20 @@ export function createCli(_argv: readonly string[] = process.argv): CAC {
         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.',
             )
           }
 
@@ -240,17 +261,55 @@ export function createCli(_argv: readonly string[] = process.argv): CAC {
             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'),
           )
         }
@@ -293,6 +352,26 @@ function buildIntegrationOptions(options: IntegrationCommandOptions): InstallInt
     }
   }
 
+  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
 }