@tpmjs/cli 0.1.2 → 0.1.4

package/dist/commands/scenario/run.js

@@ -0,0 +1,663 @@
+import { Command, Args, Flags } from '@oclif/core';
+import Conf from 'conf';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Table from 'cli-table3';
+import ora from 'ora';
+import pc from 'picocolors';
+
+// src/commands/scenario/run.ts
+var CONFIG_DIR = path.join(os.homedir(), ".tpmjs");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+path.join(CONFIG_DIR, "history");
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+var configStore = new Conf({
+  projectName: "tpmjs",
+  cwd: CONFIG_DIR,
+  configName: "config",
+  defaults: {
+    apiUrl: "https://tpmjs.com/api",
+    defaultOutput: "human",
+    verbose: false,
+    analytics: false
+  }
+});
+function getConfigValue(key) {
+  return configStore.get(key);
+}
+function loadCredentials() {
+  ensureConfigDir();
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function getApiKey() {
+  if (process.env.TPMJS_API_KEY) {
+    return process.env.TPMJS_API_KEY;
+  }
+  const creds = loadCredentials();
+  if (creds?.apiKey) {
+    return creds.apiKey;
+  }
+  return void 0;
+}
+function getApiUrl() {
+  return process.env.TPMJS_API_URL ?? getConfigValue("apiUrl") ?? "https://tpmjs.com/api";
+}
+
+// src/lib/api-client.ts
+var TpmClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? getApiUrl();
+    this.apiKey = options.apiKey ?? getApiKey();
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new ApiError(
+          data.message || data.error || `HTTP ${response.status}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // Health check
+  async health() {
+    return this.request("/health");
+  }
+  // Stats
+  async getStats() {
+    return this.request("/stats");
+  }
+  // Tools
+  async searchTools(options = {}) {
+    const params = new URLSearchParams();
+    if (options.query) params.set("q", options.query);
+    if (options.category) params.set("category", options.category);
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/tools?${queryString}` : "/tools";
+    return this.request(endpoint);
+  }
+  async getTool(packageName, toolName) {
+    return this.request(
+      `/tools/${encodeURIComponent(packageName)}/${encodeURIComponent(toolName)}`
+    );
+  }
+  async getToolBySlug(slug) {
+    const searchResult = await this.searchTools({ query: slug, limit: 1 });
+    if (searchResult.data && searchResult.data.length > 0) {
+      const tool = searchResult.data.find((t) => t.slug === slug) || searchResult.data[0];
+      return { success: true, data: tool };
+    }
+    return { success: false, error: "Tool not found" };
+  }
+  async getTrendingTools(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/tools/trending?${queryString}` : "/tools/trending";
+    return this.request(endpoint);
+  }
+  async validateTpmjsField(field) {
+    return this.request("/tools/validate", {
+      method: "POST",
+      body: JSON.stringify(field)
+    });
+  }
+  async executeTool(slug, params) {
+    return this.request(`/tools/${encodeURIComponent(slug)}/execute`, {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async *executeToolStream(slug, params) {
+    const url = `${this.baseUrl}/tools/${encodeURIComponent(slug)}/execute`;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...params, stream: true })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ApiError(errorText || `HTTP ${response.status}`, response.status);
+    }
+    if (!response.body) {
+      throw new ApiError("No response body", 0);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          yield { type: "done", data: "" };
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              yield { type: "done", data: "" };
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              yield { type: parsed.type || "text", data: parsed.content || parsed.data || data };
+            } catch {
+              yield { type: "text", data };
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  // Agents
+  async listAgents(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/agents?${queryString}` : "/agents";
+    return this.request(endpoint);
+  }
+  async getAgent(id) {
+    return this.request(`/agents/${id}`);
+  }
+  async createAgent(input) {
+    return this.request("/agents", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async updateAgent(id, input) {
+    return this.request(`/agents/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteAgent(id) {
+    return this.request(`/agents/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Collections
+  async listCollections(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/collections?${queryString}` : "/collections";
+    return this.request(endpoint);
+  }
+  async getCollection(id) {
+    return this.request(`/collections/${id}`);
+  }
+  async createCollection(input) {
+    return this.request("/collections", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async updateCollection(id, input) {
+    return this.request(`/collections/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteCollection(id) {
+    return this.request(`/collections/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async addToolsToCollection(id, toolIds) {
+    for (const toolId of toolIds) {
+      await this.request(`/collections/${id}/tools/${toolId}`, {
+        method: "POST"
+      });
+    }
+    return { success: true };
+  }
+  async removeToolFromCollection(id, toolId) {
+    return this.request(`/collections/${id}/tools/${toolId}`, {
+      method: "DELETE"
+    });
+  }
+  // User
+  async whoami() {
+    return this.request("/user/profile");
+  }
+  async listApiKeys() {
+    return this.request("/user/tpmjs-api-keys");
+  }
+  // Scenarios
+  async listScenarios(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    if (options.collectionId) params.set("collectionId", options.collectionId);
+    if (options.tags) params.set("tags", options.tags);
+    if (options.sortBy) params.set("sortBy", options.sortBy);
+    const queryString = params.toString();
+    const endpoint = queryString ? `/scenarios?${queryString}` : "/scenarios";
+    return this.request(endpoint);
+  }
+  async listCollectionScenarios(collectionId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/collections/${collectionId}/scenarios?${queryString}` : `/collections/${collectionId}/scenarios`;
+    return this.request(endpoint);
+  }
+  async getScenario(id) {
+    return this.request(`/scenarios/${id}`);
+  }
+  async createScenario(input) {
+    return this.request("/scenarios", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async generateScenarios(collectionId, input = {}) {
+    return this.request(`/collections/${collectionId}/scenarios/generate`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async runScenario(scenarioId) {
+    return this.request(`/scenarios/${scenarioId}/run`, {
+      method: "POST"
+    });
+  }
+  async getScenarioRuns(scenarioId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/scenarios/${scenarioId}/runs?${queryString}` : `/scenarios/${scenarioId}/runs`;
+    return this.request(endpoint);
+  }
+  // Check if authenticated
+  isAuthenticated() {
+    return !!this.apiKey;
+  }
+};
+var ApiError = class extends Error {
+  constructor(message, statusCode, data) {
+    super(message);
+    this.statusCode = statusCode;
+    this.data = data;
+    this.name = "ApiError";
+  }
+};
+var clientInstance = null;
+function getClient(options) {
+  if (!clientInstance || options) {
+    clientInstance = new TpmClient(options);
+  }
+  return clientInstance;
+}
+var OutputFormatter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  // Output as JSON
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  // Output a table
+  table(data, columns) {
+    if (this.options.json) {
+      this.json(data);
+      return;
+    }
+    const table = new Table({
+      head: columns.map((col) => pc.bold(col.header)),
+      colWidths: columns.map((col) => col.width ?? null),
+      style: {
+        head: [],
+        border: []
+      }
+    });
+    for (const row of data) {
+      table.push(columns.map((col) => String(row[col.key] ?? "")));
+    }
+    console.log(table.toString());
+  }
+  // Success message
+  success(message) {
+    if (this.options.json) return;
+    console.log(pc.green("\u2713"), message);
+  }
+  // Error message
+  error(message, details) {
+    if (this.options.json) {
+      this.json({ error: message, details });
+      return;
+    }
+    console.error(pc.red("\u2717"), message);
+    if (details && this.options.verbose) {
+      console.error(pc.dim(details));
+    }
+  }
+  // Warning message
+  warning(message) {
+    if (this.options.json) return;
+    console.log(pc.yellow("\u26A0"), message);
+  }
+  // Info message
+  info(message) {
+    if (this.options.json) return;
+    console.log(pc.blue("\u2139"), message);
+  }
+  // Debug message (only in verbose mode)
+  debug(message) {
+    if (this.options.json) return;
+    if (this.options.verbose) {
+      console.log(pc.dim(`[debug] ${message}`));
+    }
+  }
+  // Plain text output
+  text(message) {
+    if (this.options.json) return;
+    console.log(message);
+  }
+  // Heading
+  heading(text) {
+    if (this.options.json) return;
+    console.log();
+    console.log(pc.bold(pc.underline(text)));
+    console.log();
+  }
+  // Subheading
+  subheading(text) {
+    if (this.options.json) return;
+    console.log(pc.bold(text));
+  }
+  // Key-value pair
+  keyValue(key, value) {
+    if (this.options.json) return;
+    console.log(`${pc.dim(key + ":")} ${value ?? pc.dim("(not set)")}`);
+  }
+  // List item
+  listItem(text, indent = 0) {
+    if (this.options.json) return;
+    const prefix = "  ".repeat(indent) + "\u2022";
+    console.log(`${prefix} ${text}`);
+  }
+  // Spinner
+  spinner(message) {
+    return ora({
+      text: message,
+      isSilent: this.options.json
+    }).start();
+  }
+  // Blank line
+  newLine() {
+    if (this.options.json) return;
+    console.log();
+  }
+  // Horizontal rule
+  hr() {
+    if (this.options.json) return;
+    console.log(pc.dim("\u2500".repeat(50)));
+  }
+  // Alias for hr
+  divider() {
+    this.hr();
+  }
+  // Code block
+  code(text, language) {
+    if (this.options.json) {
+      this.json({ code: text, language });
+      return;
+    }
+    console.log(pc.dim("```" + (language ?? "")));
+    console.log(text);
+    console.log(pc.dim("```"));
+  }
+  // Highlight text
+  highlight(text) {
+    return pc.cyan(text);
+  }
+  // Dim text
+  dim(text) {
+    return pc.dim(text);
+  }
+  // Bold text
+  bold(text) {
+    return pc.bold(text);
+  }
+  // Link (just returns text in terminal)
+  link(text, url) {
+    return `\x1B]8;;${url}\x07${pc.underline(pc.blue(text))}\x1B]8;;\x07`;
+  }
+  // Color helpers
+  green(text) {
+    return pc.green(text);
+  }
+  red(text) {
+    return pc.red(text);
+  }
+  yellow(text) {
+    return pc.yellow(text);
+  }
+  blue(text) {
+    return pc.blue(text);
+  }
+  cyan(text) {
+    return pc.cyan(text);
+  }
+};
+function createOutput(flags) {
+  return new OutputFormatter({
+    json: flags.json,
+    verbose: flags.verbose
+  });
+}
+
+// src/commands/scenario/run.ts
+var ScenarioRun = class _ScenarioRun extends Command {
+  static description = "Run all scenarios for a collection";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> my-collection",
+    "<%= config.bin %> <%= command.id %> my-collection --json",
+    "<%= config.bin %> <%= command.id %> my-collection --verbose"
+  ];
+  static args = {
+    collection: Args.string({
+      description: "Collection ID or slug",
+      required: true
+    })
+  };
+  static flags = {
+    json: Flags.boolean({
+      description: "Output in JSON format",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show verbose output",
+      default: false
+    }),
+    limit: Flags.integer({
+      char: "l",
+      description: "Maximum number of scenarios to run",
+      default: 50
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_ScenarioRun);
+    const output = createOutput(flags);
+    const client = getClient();
+    if (!client.isAuthenticated()) {
+      output.error("Not authenticated. Run `tpm auth login` first.");
+      return;
+    }
+    const collectionsSpinner = output.spinner("Finding collection...");
+    let collectionId;
+    try {
+      const collections = await client.listCollections({ limit: 100 });
+      const collection = collections.data.find(
+        (c) => c.id === args.collection || c.slug === args.collection
+      );
+      if (!collection) {
+        collectionsSpinner.fail("Collection not found");
+        output.error(`No collection found with ID or slug: ${args.collection}`);
+        return;
+      }
+      collectionId = collection.id;
+      collectionsSpinner.stop();
+      output.text(output.bold(`Running scenarios for: ${collection.name}
+`));
+    } catch (error) {
+      collectionsSpinner.fail("Failed to find collection");
+      output.error(error instanceof Error ? error.message : "Unknown error");
+      return;
+    }
+    const scenariosSpinner = output.spinner("Fetching scenarios...");
+    let scenarios;
+    try {
+      const response = await client.listCollectionScenarios(collectionId, { limit: flags.limit });
+      scenarios = response.data?.scenarios || [];
+      if (scenarios.length === 0) {
+        scenariosSpinner.fail("No scenarios found");
+        output.info("This collection has no scenarios. Generate some with:");
+        output.text(`  tpm scenario generate ${args.collection}`);
+        return;
+      }
+      scenariosSpinner.stop();
+      output.info(`Found ${scenarios.length} scenario(s) to run
+`);
+    } catch (error) {
+      scenariosSpinner.fail("Failed to fetch scenarios");
+      output.error(error instanceof Error ? error.message : "Unknown error");
+      return;
+    }
+    const results = [];
+    let passed = 0;
+    let failed = 0;
+    let errors = 0;
+    for (const scenario of scenarios) {
+      const name = scenario.name || scenario.prompt.slice(0, 40) + "...";
+      const runSpinner = output.spinner(`Running: ${name}`);
+      try {
+        const result = await client.runScenario(scenario.id);
+        const runData = result.data;
+        if (runData.success) {
+          passed++;
+          runSpinner.succeed(`${output.green("\u2713")} ${name}`);
+        } else if (runData.status === "error") {
+          errors++;
+          runSpinner.fail(`${output.red("\u2717")} ${name} (error)`);
+        } else {
+          failed++;
+          runSpinner.fail(`${output.red("\u2717")} ${name}`);
+        }
+        if (flags.verbose && runData.evaluator?.reason) {
+          output.text(output.dim(`  \u2192 ${runData.evaluator.reason}`));
+        }
+        results.push({
+          name,
+          status: runData.status,
+          verdict: runData.evaluator?.verdict ?? null,
+          reason: runData.evaluator?.reason ?? null,
+          timeMs: runData.usage?.executionTimeMs ?? null
+        });
+      } catch (error) {
+        errors++;
+        runSpinner.fail(`${output.red("\u2717")} ${name} (error)`);
+        results.push({
+          name,
+          status: "error",
+          verdict: null,
+          reason: error instanceof Error ? error.message : "Unknown error",
+          timeMs: null
+        });
+      }
+    }
+    output.newLine();
+    output.text(output.bold("\u2500".repeat(50)));
+    output.text(output.bold("Summary"));
+    output.text(`  ${output.green("Passed:")} ${passed}`);
+    output.text(`  ${output.red("Failed:")} ${failed}`);
+    if (errors > 0) {
+      output.text(`  ${output.yellow("Errors:")} ${errors}`);
+    }
+    output.text(`  ${output.dim("Total:")} ${scenarios.length}`);
+    const passRate = scenarios.length > 0 ? passed / scenarios.length * 100 : 0;
+    output.newLine();
+    output.text(`Pass rate: ${passRate.toFixed(1)}%`);
+    if (flags.json) {
+      output.newLine();
+      output.json({
+        collection: args.collection,
+        total: scenarios.length,
+        passed,
+        failed,
+        errors,
+        passRate: passRate.toFixed(1),
+        results
+      });
+    }
+    if (failed > 0 || errors > 0) {
+      this.exit(1);
+    }
+  }
+};
+
+export { ScenarioRun as default };
+//# sourceMappingURL=run.js.map
+//# sourceMappingURL=run.js.map