@boolesai/tspec-cli 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,10 +1,12 @@
 import { Command } from "commander";
+import { existsSync, statSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { isAbsolute, resolve as resolve$1, basename, relative, dirname, join } from "path";
 import ora from "ora";
-import { getTypeFromFilePath, validateTestCase, clearTemplateCache, parseTestCases, scheduler, registry as registry$1 } from "@boolesai/tspec";
+import { getTypeFromFilePath, isSuiteFile, getSuiteProtocolType, validateTestCase, clearTemplateCache, getPluginManager, version as version$1, registry as registry$1, executeSuite, parseTestCases, scheduler, PluginManager } from "@boolesai/tspec";
 import { glob } from "glob";
-import { isAbsolute, resolve as resolve$1, basename, relative } from "path";
-import { existsSync, statSync } from "fs";
 import chalk from "chalk";
+import { findConfigFile, findLocalConfigFile, findGlobalConfigFile, PLUGINS_DIR, isPluginInstalled, installPlugin, GLOBAL_CONFIG_PATH } from "@boolesai/tspec/plugin";
 import process$2 from "node:process";
 async function discoverTSpecFiles(patterns, cwd) {
   const workingDir = process.cwd();
@@ -15,14 +17,14 @@ async function discoverTSpecFiles(patterns, cwd) {
     if (existsSync(absolutePath)) {
       const stat = statSync(absolutePath);
       if (stat.isFile()) {
-        if (absolutePath.endsWith(".tspec")) {
+        if (absolutePath.endsWith(".tcase")) {
           filePaths.push(absolutePath);
         }
         continue;
       } else if (stat.isDirectory()) {
-        const dirFiles = await glob("**/*.tspec", { cwd: absolutePath, absolute: true });
+        const dirFiles = await glob("**/*.tcase", { cwd: absolutePath, absolute: true });
         if (dirFiles.length === 0) {
-          errors2.push(`No .tspec files found in directory: ${pattern2}`);
+          errors2.push(`No .tcase files found in directory: ${pattern2}`);
         } else {
           filePaths.push(...dirFiles);
         }
@@ -30,9 +32,9 @@ async function discoverTSpecFiles(patterns, cwd) {
       }
     }
     const matches = await glob(pattern2, { cwd: workingDir, absolute: true });
-    const tspecMatches = matches.filter((f) => f.endsWith(".tspec"));
+    const tspecMatches = matches.filter((f) => f.endsWith(".tcase"));
     if (tspecMatches.length === 0) {
-      errors2.push(`No .tspec files matched pattern: ${pattern2}`);
+      errors2.push(`No .tcase files matched pattern: ${pattern2}`);
     } else {
       filePaths.push(...tspecMatches);
     }
@@ -46,6 +48,61 @@ async function discoverTSpecFiles(patterns, cwd) {
   }));
   return { files, errors: errors2 };
 }
+async function discoverAllTestFiles(patterns, cwd) {
+  const workingDir = process.cwd();
+  const tspecPaths = [];
+  const suitePaths = [];
+  const errors2 = [];
+  for (const pattern2 of patterns) {
+    const absolutePath = isAbsolute(pattern2) ? pattern2 : resolve$1(workingDir, pattern2);
+    if (existsSync(absolutePath)) {
+      const stat = statSync(absolutePath);
+      if (stat.isFile()) {
+        if (absolutePath.endsWith(".tcase")) {
+          tspecPaths.push(absolutePath);
+        } else if (isSuiteFile(absolutePath)) {
+          suitePaths.push(absolutePath);
+        }
+        continue;
+      } else if (stat.isDirectory()) {
+        const tspecFiles2 = await glob("**/*.tcase", { cwd: absolutePath, absolute: true });
+        const suiteFiles2 = await glob("**/*.tsuite", { cwd: absolutePath, absolute: true });
+        if (tspecFiles2.length === 0 && suiteFiles2.length === 0) {
+          errors2.push(`No .tcase or .tsuite files found in directory: ${pattern2}`);
+        } else {
+          tspecPaths.push(...tspecFiles2);
+          suitePaths.push(...suiteFiles2);
+        }
+        continue;
+      }
+    }
+    const matches = await glob(pattern2, { cwd: workingDir, absolute: true });
+    const tspecMatches = matches.filter((f) => f.endsWith(".tcase"));
+    const suiteMatches = matches.filter((f) => isSuiteFile(f));
+    if (tspecMatches.length === 0 && suiteMatches.length === 0) {
+      errors2.push(`No .tcase or .tsuite files matched pattern: ${pattern2}`);
+    } else {
+      tspecPaths.push(...tspecMatches);
+      suitePaths.push(...suiteMatches);
+    }
+  }
+  const uniqueTspecPaths = [...new Set(tspecPaths)];
+  const uniqueSuitePaths = [...new Set(suitePaths)];
+  const tspecFiles = uniqueTspecPaths.map((filePath) => ({
+    path: filePath,
+    relativePath: relative(workingDir, filePath),
+    fileName: basename(filePath),
+    protocol: getTypeFromFilePath(filePath)
+  }));
+  const suiteFiles = uniqueSuitePaths.map((filePath) => ({
+    path: filePath,
+    relativePath: relative(workingDir, filePath),
+    fileName: basename(filePath),
+    protocol: getSuiteProtocolType(filePath),
+    isTemplate: filePath.endsWith(".tsuite.yaml")
+  }));
+  return { tspecFiles, suiteFiles, errors: errors2 };
+}
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
@@ -199,7 +256,7 @@ async function executeValidate(params) {
   if (fileDescriptors.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase files found",
       data: { results: [] }
     };
   }
@@ -222,7 +279,7 @@ async function executeValidate(params) {
     data: { results }
   };
 }
-const validateCommand = new Command("validate").description("Validate .tspec files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").action(async (files, options) => {
+const validateCommand = new Command("validate").description("Validate .tcase files for schema correctness").argument("<files...>", "Files or glob patterns to validate").option("-o, --output <format>", "Output format: json, text", "text").option("-q, --quiet", "Only output errors").action(async (files, options) => {
   setLoggerOptions({ quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Validating...").start();
   try {
@@ -297,6 +354,14 @@ async function runFileTestCasesInternal(descriptor, env, params, concurrency, fa
 }
 async function executeRun(params) {
   clearTemplateCache();
+  const configPath = params.config || findConfigFile();
+  if (configPath) {
+    const pluginManager = getPluginManager(version$1);
+    await pluginManager.initialize(configPath, {
+      skipAutoInstall: params.noAutoInstall
+    });
+    registry$1.enablePluginManager();
+  }
   const concurrency = params.concurrency ?? 5;
   const env = params.env ?? {};
   const paramValues = params.params ?? {};
@@ -304,11 +369,11 @@ async function executeRun(params) {
   const output = params.output ?? "text";
   const verbose = params.verbose ?? false;
   const quiet = params.quiet ?? false;
-  const { files: fileDescriptors, errors: resolveErrors } = await discoverTSpecFiles(params.files);
-  if (fileDescriptors.length === 0) {
+  const { tspecFiles, suiteFiles, errors: resolveErrors } = await discoverAllTestFiles(params.files);
+  if (tspecFiles.length === 0 && suiteFiles.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase or .tsuite files found",
       data: {
         results: [],
         summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
@@ -316,6 +381,29 @@ async function executeRun(params) {
       }
     };
   }
+  if (suiteFiles.length > 0) {
+    return executeSuiteRun(suiteFiles, tspecFiles, {
+      env,
+      params: paramValues,
+      concurrency,
+      failFast,
+      output,
+      verbose,
+      quiet
+    });
+  }
+  return executeTspecRun(tspecFiles, {
+    env,
+    params: paramValues,
+    concurrency,
+    failFast,
+    output,
+    verbose,
+    quiet
+  });
+}
+async function executeTspecRun(fileDescriptors, options) {
+  const { env, params: paramValues, concurrency, failFast, output, verbose, quiet } = options;
   const allResults = [];
   const parseErrors = [];
   let totalTestCases = 0;
@@ -384,7 +472,117 @@ ${parseErrors.length} file(s) failed to parse:`);
     data: { results: formattedResults, summary, parseErrors }
   };
 }
-const runCommand = new Command("run").description("Execute test cases and report results").argument("<files...>", "Files or glob patterns to run").option("-o, --output <format>", "Output format: json, text", "text").option("-c, --concurrency <number>", "Max concurrent tests", "5").option("-e, --env <key=value>", "Environment variables", parseKeyValue$1, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue$1, {}).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Only output summary").option("--fail-fast", "Stop on first failure").action(async (files, options) => {
+async function executeSuiteRun(suiteFiles, additionalTspecFiles, options) {
+  const { env, params: paramValues, failFast, output, verbose, quiet } = options;
+  const allResults = [];
+  const parseErrors = [];
+  let totalTests = 0;
+  let totalPassed = 0;
+  let totalFailed = 0;
+  let stopped = false;
+  for (const suiteDescriptor of suiteFiles) {
+    if (stopped) break;
+    if (suiteDescriptor.isTemplate) continue;
+    try {
+      const suiteResult = await executeSuite(suiteDescriptor.path, {
+        env,
+        params: paramValues,
+        onSuiteStart: (name) => {
+          if (!quiet) logger.log(chalk.blue(`
+Suite: ${name}`));
+        },
+        onTestStart: (file) => {
+          if (verbose) logger.log(chalk.gray(`  Running: ${file}`));
+        },
+        onTestComplete: (file, result) => {
+          const statusIcon = result.status === "passed" ? chalk.green("✓") : chalk.red("✗");
+          if (!quiet) logger.log(`  ${statusIcon} ${result.name} (${result.duration}ms)`);
+        }
+      });
+      totalTests += suiteResult.stats.total;
+      totalPassed += suiteResult.stats.passed;
+      totalFailed += suiteResult.stats.failed + suiteResult.stats.error;
+      for (const testResult of suiteResult.tests) {
+        allResults.push({
+          testCaseId: testResult.name,
+          passed: testResult.status === "passed",
+          duration: testResult.duration,
+          assertions: (testResult.assertions || []).map((a) => ({
+            passed: a.passed,
+            type: a.type,
+            message: a.message || ""
+          }))
+        });
+      }
+      if (suiteResult.suites) {
+        for (const nestedSuite of suiteResult.suites) {
+          totalTests += nestedSuite.stats.total;
+          totalPassed += nestedSuite.stats.passed;
+          totalFailed += nestedSuite.stats.failed + nestedSuite.stats.error;
+          for (const testResult of nestedSuite.tests) {
+            allResults.push({
+              testCaseId: `${nestedSuite.name}/${testResult.name}`,
+              passed: testResult.status === "passed",
+              duration: testResult.duration,
+              assertions: (testResult.assertions || []).map((a) => ({
+                passed: a.passed,
+                type: a.type,
+                message: a.message || ""
+              }))
+            });
+          }
+        }
+      }
+      if (failFast && (suiteResult.status === "failed" || suiteResult.status === "error")) {
+        stopped = true;
+      }
+    } catch (err) {
+      parseErrors.push({
+        file: suiteDescriptor.path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (additionalTspecFiles.length > 0 && !stopped) {
+    const tspecResult = await executeTspecRun(additionalTspecFiles, options);
+    allResults.push(...tspecResult.data.results);
+    parseErrors.push(...tspecResult.data.parseErrors);
+    totalTests += tspecResult.data.summary.total;
+    totalPassed += tspecResult.data.summary.passed;
+    totalFailed += tspecResult.data.summary.failed;
+  }
+  const summary = {
+    total: totalTests,
+    passed: totalPassed,
+    failed: totalFailed,
+    passRate: totalTests > 0 ? totalPassed / totalTests * 100 : 0,
+    duration: 0
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = formatJson({ results: allResults, summary, parseErrors });
+  } else {
+    const parts = [];
+    if (!quiet) {
+      parts.push("\n" + chalk.bold("Results:"));
+      parts.push(formatTestResults(allResults, summary, { format: output, verbose }));
+    } else {
+      parts.push(`${summary.passed}/${summary.total} tests passed (${summary.passRate.toFixed(1)}%)`);
+    }
+    if (parseErrors.length > 0) {
+      parts.push(`
+${parseErrors.length} file(s) failed to parse:`);
+      parseErrors.forEach(({ file, error: error2 }) => parts.push(`  ${file}: ${error2}`));
+    }
+    outputStr = parts.join("\n");
+  }
+  return {
+    success: totalFailed === 0 && parseErrors.length === 0,
+    output: outputStr,
+    data: { results: allResults, summary, parseErrors }
+  };
+}
+const runCommand = new Command("run").description("Execute test cases and report results").argument("<files...>", "Files or glob patterns to run").option("-o, --output <format>", "Output format: json, text", "text").option("-c, --concurrency <number>", "Max concurrent tests", "5").option("-e, --env <key=value>", "Environment variables", parseKeyValue$1, {}).option("-p, --params <key=value>", "Parameters", parseKeyValue$1, {}).option("-v, --verbose", "Verbose output").option("-q, --quiet", "Only output summary").option("--fail-fast", "Stop on first failure").option("--config <path>", "Path to tspec.config.json for plugin loading").option("--no-auto-install", "Skip automatic plugin installation").action(async (files, options) => {
   setLoggerOptions({ verbose: options.verbose, quiet: options.quiet });
   const spinner = options.quiet ? null : ora("Running tests...").start();
   try {
@@ -395,6 +593,8 @@ const runCommand = new Command("run").description("Execute test cases and report
       verbose: options.verbose,
       quiet: options.quiet,
       failFast: options.failFast,
+      config: options.config,
+      noAutoInstall: options.noAutoInstall,
       env: options.env,
       params: options.params
     });
@@ -415,9 +615,20 @@ const runCommand = new Command("run").description("Execute test cases and report
     }
     process.exit(result.success ? 0 : 1);
   } catch (err) {
-    spinner?.fail("Execution failed");
+    spinner?.stop();
     const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
+    if (options.output === "json") {
+      const errorOutput = formatJson({
+        results: [],
+        summary: { total: 0, passed: 0, failed: 0, passRate: 0, duration: 0 },
+        parseErrors: [],
+        error: message
+      });
+      logger.log(errorOutput);
+    } else {
+      spinner?.fail("Execution failed");
+      logger.error(message);
+    }
     process.exit(2);
   }
 });
@@ -438,7 +649,7 @@ async function executeParse(params) {
   if (fileDescriptors.length === 0) {
     return {
       success: false,
-      output: "No .tspec files found",
+      output: "No .tcase files found",
       data: {
         testCases: [],
         parseErrors: [],
@@ -14756,7 +14967,7 @@ const TOOL_DEFINITIONS = [
         files: {
           type: "array",
           items: { type: "string" },
-          description: 'Files or glob patterns to run (e.g., ["tests/*.tspec"])'
+          description: 'Files or glob patterns to run (e.g., ["tests/*.tcase"])'
         },
         concurrency: {
           type: "number",
@@ -14787,7 +14998,7 @@ const TOOL_DEFINITIONS = [
   },
   {
     name: "tspec_validate",
-    description: "Validate .tspec files for schema correctness",
+    description: "Validate .tcase files for schema correctness",
     inputSchema: {
       type: "object",
       properties: {
@@ -14949,12 +15160,273 @@ const mcpCommand = new Command("mcp").description("Start MCP server for tool int
   setLoggerOptions({ quiet: true });
   await startMcpServer();
 });
+async function executePluginList(params) {
+  const output = params.output ?? "text";
+  const pluginManager = new PluginManager(version$1);
+  const localConfigPath = findLocalConfigFile();
+  const globalConfigPath = findGlobalConfigFile();
+  const configPath = params.config || localConfigPath || globalConfigPath;
+  let loadSummary;
+  if (configPath) {
+    loadSummary = await pluginManager.initialize(configPath);
+  }
+  const plugins = pluginManager.list();
+  const protocols = pluginManager.listProtocols();
+  let healthReports;
+  if (params.health) {
+    healthReports = await pluginManager.healthCheck();
+  }
+  const data = {
+    plugins: plugins.map((p) => ({
+      name: p.name,
+      version: p.version,
+      description: p.description,
+      protocols: p.protocols,
+      author: p.author,
+      homepage: p.homepage
+    })),
+    protocols,
+    configPath: configPath || void 0,
+    configSources: {
+      local: localConfigPath || void 0,
+      global: globalConfigPath || void 0
+    },
+    pluginsDir: PLUGINS_DIR,
+    health: healthReports
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = JSON.stringify(data, null, 2);
+  } else {
+    outputStr = formatPluginListText(data, params.verbose ?? false, loadSummary);
+  }
+  return {
+    success: true,
+    output: outputStr,
+    data
+  };
+}
+function formatPluginListText(data, verbose, loadSummary) {
+  const lines = [];
+  lines.push(chalk.bold("\nTSpec Plugins\n"));
+  lines.push(chalk.bold("Config:"));
+  if (data.configSources?.local) {
+    lines.push(chalk.gray(`  Local:  ${data.configSources.local}`));
+  } else {
+    lines.push(chalk.gray("  Local:  (none)"));
+  }
+  if (data.configSources?.global) {
+    lines.push(chalk.gray(`  Global: ${data.configSources.global}`));
+  } else {
+    lines.push(chalk.gray("  Global: (none)"));
+  }
+  lines.push(chalk.gray(`  Plugins dir: ${data.pluginsDir}`));
+  if (loadSummary) {
+    lines.push("");
+    lines.push(chalk.gray(`Discovered: ${loadSummary.total}, Loaded: ${loadSummary.loaded}`));
+    if (loadSummary.installed && loadSummary.installed > 0) {
+      lines.push(chalk.green(`Installed: ${loadSummary.installed} plugin(s)`));
+    }
+    if (loadSummary.failed > 0) {
+      lines.push(chalk.red(`Failed: ${loadSummary.failed}`));
+      for (const error2 of loadSummary.errors) {
+        lines.push(chalk.red(`  ${error2.plugin}: ${error2.error}`));
+      }
+    }
+    if (loadSummary.installErrors && loadSummary.installErrors.length > 0) {
+      lines.push(chalk.red(`Install failures:`));
+      for (const error2 of loadSummary.installErrors) {
+        lines.push(chalk.red(`  ${error2.plugin}: ${error2.error}`));
+      }
+    }
+  }
+  lines.push("");
+  if (data.plugins.length === 0) {
+    lines.push(chalk.yellow("No plugins loaded."));
+    lines.push(chalk.gray("Add plugins to your tspec.config.json:"));
+    lines.push(chalk.gray("  {"));
+    lines.push(chalk.gray('    "plugins": ["@tspec/http", "@tspec/web"]'));
+    lines.push(chalk.gray("  }"));
+  } else {
+    for (const plugin of data.plugins) {
+      lines.push(`${chalk.cyan(plugin.name)} ${chalk.gray(`v${plugin.version}`)}`);
+      if (verbose && plugin.description) {
+        lines.push(`  ${plugin.description}`);
+      }
+      lines.push(`  Protocols: ${plugin.protocols.join(", ")}`);
+      if (verbose) {
+        if (plugin.author) {
+          lines.push(`  Author: ${plugin.author}`);
+        }
+        if (plugin.homepage) {
+          lines.push(`  Homepage: ${plugin.homepage}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (data.health) {
+    lines.push(chalk.bold("Health Check\n"));
+    for (const report of data.health) {
+      const status = report.healthy ? chalk.green("✓ Healthy") : chalk.red("✗ Unhealthy");
+      lines.push(`${chalk.cyan(report.plugin)}: ${status}`);
+      if (report.message) {
+        lines.push(`  ${report.message}`);
+      }
+    }
+    lines.push("");
+  }
+  if (data.protocols.length > 0) {
+    lines.push(chalk.bold("Supported Protocols: ") + data.protocols.join(", "));
+  }
+  return lines.join("\n");
+}
+const pluginListCommand = new Command("plugin:list").alias("plugins").description("List all installed TSpec plugins").option("-o, --output <format>", "Output format: json, text", "text").option("-v, --verbose", "Show detailed plugin information").option("--health", "Run health checks on all plugins").option("-c, --config <path>", "Path to tspec.config.json").action(async (options) => {
+  try {
+    const result = await executePluginList({
+      output: options.output,
+      verbose: options.verbose,
+      health: options.health,
+      config: options.config
+    });
+    logger.log(result.output);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to list plugins: ${message}`);
+    process.exit(2);
+  }
+});
+function loadConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return { plugins: [], pluginOptions: {} };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { plugins: [], pluginOptions: {} };
+  }
+}
+function saveConfigFile(configPath, config2) {
+  const dir = configPath.substring(0, configPath.lastIndexOf("/"));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n");
+}
+function addPluginToConfig(config2, pluginName) {
+  if (!config2.plugins) {
+    config2.plugins = [];
+  }
+  if (config2.plugins.includes(pluginName)) {
+    return false;
+  }
+  config2.plugins.push(pluginName);
+  return true;
+}
+async function executePluginInstall(params) {
+  const { pluginName, output = "text", global: useGlobal = false, config: customConfig } = params;
+  let configPath;
+  if (customConfig) {
+    configPath = customConfig;
+  } else if (useGlobal) {
+    configPath = GLOBAL_CONFIG_PATH;
+  } else {
+    const localConfig = findLocalConfigFile();
+    configPath = localConfig || GLOBAL_CONFIG_PATH;
+  }
+  const alreadyInstalled = isPluginInstalled(pluginName);
+  let installed = false;
+  let installError;
+  if (!alreadyInstalled) {
+    const result = await installPlugin(pluginName);
+    installed = result.success;
+    if (!result.success) {
+      installError = result.error;
+    }
+  } else {
+    installed = true;
+  }
+  let configUpdated = false;
+  if (installed) {
+    const config2 = loadConfigFile(configPath);
+    configUpdated = addPluginToConfig(config2, pluginName);
+    if (configUpdated) {
+      saveConfigFile(configPath, config2);
+    }
+  }
+  const data = {
+    plugin: pluginName,
+    installed,
+    configUpdated,
+    configPath: installed ? configPath : void 0,
+    error: installError
+  };
+  let outputStr;
+  if (output === "json") {
+    outputStr = JSON.stringify(data, null, 2);
+  } else {
+    if (!installed) {
+      outputStr = chalk.red(`Failed to install ${pluginName}: ${installError || "Unknown error"}`);
+    } else if (alreadyInstalled && !configUpdated) {
+      outputStr = chalk.yellow(`Plugin ${pluginName} is already installed and configured.`);
+    } else if (alreadyInstalled && configUpdated) {
+      outputStr = [
+        chalk.green(`Plugin ${pluginName} is already installed.`),
+        chalk.green(`Added to config: ${configPath}`)
+      ].join("\n");
+    } else if (configUpdated) {
+      outputStr = [
+        chalk.green(`Successfully installed ${pluginName}`),
+        chalk.green(`Added to config: ${configPath}`)
+      ].join("\n");
+    } else {
+      outputStr = [
+        chalk.green(`Successfully installed ${pluginName}`),
+        chalk.yellow(`Plugin already in config: ${configPath}`)
+      ].join("\n");
+    }
+  }
+  return {
+    success: installed,
+    output: outputStr,
+    data
+  };
+}
+const pluginInstallCommand = new Command("plugin:install").alias("install").description("Install a TSpec plugin and add it to config").argument("<plugin>", "Plugin name (npm package name, e.g., @tspec/http)").option("-o, --output <format>", "Output format: json, text", "text").option("-g, --global", "Add plugin to global config (~/.tspec/tspec.config.json)").option("-c, --config <path>", "Path to config file to update").action(async (plugin, options) => {
+  const spinner = ora(`Installing ${plugin}...`).start();
+  try {
+    const result = await executePluginInstall({
+      pluginName: plugin,
+      output: options.output,
+      global: options.global,
+      config: options.config
+    });
+    spinner.stop();
+    logger.log(result.output);
+    process.exit(result.success ? 0 : 1);
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.output === "json") {
+      logger.log(JSON.stringify({ success: false, error: message }, null, 2));
+    } else {
+      logger.error(`Failed to install plugin: ${message}`);
+    }
+    process.exit(2);
+  }
+});
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+const packageJson = JSON.parse(readFileSync(join(__dirname$1, "../package.json"), "utf-8"));
 const program = new Command();
-program.name("tspec").description("CLI for @boolesai/tspec testing framework").version("1.0.0");
+program.name("tspec").description("CLI for @boolesai/tspec testing framework").version(packageJson.version);
 program.addCommand(validateCommand);
 program.addCommand(runCommand);
 program.addCommand(parseCommand);
 program.addCommand(listCommand);
 program.addCommand(mcpCommand);
+program.addCommand(pluginListCommand);
+program.addCommand(pluginInstallCommand);
 await program.parseAsync();
 //# sourceMappingURL=index.js.map