plexmint 0.1.0

package/README.md

@@ -0,0 +1,73 @@
+# PlexMint CLI
+
+Browse, install, and manage AI prompts from the [PlexMint](https://plexmint.com) marketplace — right from your terminal.
+
+## Quick Start
+
+```bash
+# Browse the marketplace
+npx plexmint browse
+
+# Search for prompts
+npx plexmint search "email copywriting"
+
+# Get details on a specific prompt
+npx plexmint info NUE-SEO01
+
+# Install a prompt locally
+npx plexmint install NUE-SEO01
+```
+
+## Installation
+
+```bash
+# Run directly with npx (no install needed)
+npx plexmint browse
+
+# Or install globally
+npm install -g plexmint
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `plexmint browse` | Browse the marketplace with filters |
+| `plexmint search <query>` | Search prompts by keyword |
+| `plexmint info <ticker>` | Get detailed prompt info |
+| `plexmint install <ticker>` | Download prompt to `.plexmint/` |
+| `plexmint login` | Authenticate with your account |
+| `plexmint logout` | Remove stored credentials |
+| `plexmint library` | View your purchased prompts |
+
+## Options
+
+### Search & Browse
+- `--category` — Filter: business, writing, code, seo, design, education, data, social-media, personal
+- `--model` — Filter: gpt-4o, gpt-5, claude-opus, claude-sonnet, gemini, midjourney, dall-e, etc.
+- `--sort` — Sort: trending, top_rated, most_sales, newest, price_low, price_high
+- `--limit` — Results per page (max 100)
+
+### Install
+- `--dir` — Custom install directory (default: `.plexmint/`)
+- `--force` — Overwrite existing installation
+
+### Login
+- `--api-key` — Set API key directly without interactive prompt
+
+## What is PlexMint?
+
+PlexMint is the AI prompt marketplace where **quality drives price**. Living Prompts start at $1.99 — reviews, demand, and reputation push the price up. Every prompt gets a stock-style ticker symbol (like NUE-SEO01) and a dynamic price that reflects real quality.
+
+- **For developers**: Install prompts into your agent workflows via CLI
+- **For AI agents**: Use the API to browse, purchase, and retrieve prompts programmatically
+- **For sellers**: List your prompts and let the market determine their value
+
+## API
+
+The CLI uses the PlexMint Agent API v1. Full OpenAPI spec available at:
+https://plexmint.com/api/v1/openapi.json
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk7 from "chalk";
+
+// src/commands/search.ts
+import chalk from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+
+// src/lib/api.ts
+var DEFAULT_BASE_URL = "https://plexmint.com/api/v1";
+var PlexMintClient = class {
+  baseUrl;
+  apiKey;
+  constructor(apiKey = null, baseUrl) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl || DEFAULT_BASE_URL;
+  }
+  async request(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "plexmint-cli/0.1.0",
+      ...options.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers
+    });
+    const json = await res.json();
+    if (!res.ok || !json.success) {
+      const error = json;
+      throw new PlexMintApiError(
+        error.error || `Request failed with status ${res.status}`,
+        res.status,
+        json
+      );
+    }
+    return json;
+  }
+  /**
+   * Browse/search prompts
+   */
+  async browse(options = {}) {
+    const params = new URLSearchParams();
+    if (options.query) params.set("q", options.query);
+    if (options.category) params.set("category", options.category);
+    if (options.model) params.set("model", options.model);
+    if (options.sort) params.set("sort", options.sort);
+    if (options.limit) params.set("limit", options.limit.toString());
+    const qs = params.toString();
+    return this.request(`/prompts${qs ? `?${qs}` : ""}`);
+  }
+  /**
+   * Get a single prompt by ticker
+   */
+  async getPrompt(ticker) {
+    return this.request(
+      `/prompts?ticker=${encodeURIComponent(ticker.toUpperCase())}`
+    );
+  }
+  /**
+   * Initiate a purchase (requires API key)
+   */
+  async purchase(ticker) {
+    if (!this.apiKey) {
+      throw new PlexMintApiError(
+        "Authentication required. Run: plexmint login",
+        401,
+        {}
+      );
+    }
+    return this.request("/purchase", {
+      method: "POST",
+      body: JSON.stringify({ ticker: ticker.toUpperCase() })
+    });
+  }
+  /**
+   * Get prompt content (requires purchase)
+   */
+  async getContent(ticker) {
+    if (!this.apiKey) {
+      throw new PlexMintApiError(
+        "Authentication required. Run: plexmint login",
+        401,
+        {}
+      );
+    }
+    return this.request(
+      `/library/${encodeURIComponent(ticker.toUpperCase())}/content`
+    );
+  }
+  /**
+   * Authenticate with email/password
+   */
+  async authenticate(email, password) {
+    return this.request("/auth", {
+      method: "POST",
+      body: JSON.stringify({ email, password })
+    });
+  }
+};
+var PlexMintApiError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "PlexMintApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/lib/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "plexmint",
+  defaults: {
+    apiKey: null,
+    baseUrl: "https://plexmint.com/api/v1",
+    username: null,
+    email: null
+  }
+});
+function getApiKey() {
+  return config.get("apiKey");
+}
+function setApiKey(key) {
+  config.set("apiKey", key);
+}
+function getBaseUrl() {
+  return config.get("baseUrl");
+}
+function setUserInfo(username, email) {
+  config.set("username", username);
+  config.set("email", email);
+}
+function clearAuth() {
+  config.set("apiKey", null);
+  config.set("username", null);
+  config.set("email", null);
+}
+function isAuthenticated() {
+  return !!config.get("apiKey");
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/commands/search.ts
+async function searchCommand(query, options) {
+  const spinner = ora(`Searching for "${query}"...`).start();
+  try {
+    const client = new PlexMintClient(getApiKey(), getBaseUrl());
+    const result = await client.browse({
+      query,
+      category: options.category,
+      model: options.model,
+      sort: options.sort || "trending",
+      limit: options.limit ? parseInt(options.limit) : 12
+    });
+    spinner.stop();
+    const { items } = result.data;
+    if (items.length === 0) {
+      console.log(chalk.yellow(`
+  No prompts found for "${query}"
+`));
+      return;
+    }
+    console.log(
+      chalk.bold(`
+  Found ${items.length} prompt${items.length > 1 ? "s" : ""}
+`)
+    );
+    const table = new Table({
+      head: [
+        chalk.cyan("Ticker"),
+        chalk.cyan("Title"),
+        chalk.cyan("Price"),
+        chalk.cyan("Rating"),
+        chalk.cyan("Sales"),
+        chalk.cyan("Seller")
+      ],
+      style: { head: [], border: ["gray"] },
+      colWidths: [14, 30, 10, 10, 8, 16]
+    });
+    for (const prompt2 of items) {
+      const price = parseFloat(prompt2.currentPrice);
+      const rating = parseFloat(prompt2.averageRating);
+      table.push([
+        chalk.bold(prompt2.ticker),
+        prompt2.title.length > 28 ? prompt2.title.slice(0, 25) + "..." : prompt2.title,
+        chalk.green(`$${price.toFixed(2)}`),
+        rating > 0 ? chalk.yellow(`\u2605 ${rating.toFixed(1)}`) : chalk.gray("\u2014"),
+        prompt2.salesCount.toString(),
+        prompt2.seller?.username ? chalk.gray(`@${prompt2.seller.username}`) : chalk.gray("\u2014")
+      ]);
+    }
+    console.log(table.toString());
+    if (result.data.hasMore) {
+      console.log(chalk.gray("\n  More results available. Use --limit to see more.\n"));
+    }
+    console.log(
+      chalk.gray(`  Install a prompt: `) + chalk.white(`plexmint install <TICKER>
+`)
+    );
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      console.error(chalk.red(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(chalk.red(`
+  Connection error. Is plexmint.com reachable?
+`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/browse.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import Table2 from "cli-table3";
+async function browseCommand(options) {
+  const spinner = ora2("Browsing PlexMint marketplace...").start();
+  try {
+    const client = new PlexMintClient(getApiKey(), getBaseUrl());
+    const result = await client.browse({
+      category: options.category,
+      model: options.model,
+      sort: options.sort || "trending",
+      limit: options.limit ? parseInt(options.limit) : 20
+    });
+    spinner.stop();
+    const { items } = result.data;
+    if (items.length === 0) {
+      console.log(chalk2.yellow("\n  No prompts found.\n"));
+      return;
+    }
+    const sortLabel = options.sort || "trending";
+    console.log(
+      chalk2.bold(`
+  PlexMint Marketplace`) + chalk2.gray(` \u2014 sorted by ${sortLabel}
+`)
+    );
+    const table = new Table2({
+      head: [
+        chalk2.cyan("Ticker"),
+        chalk2.cyan("Title"),
+        chalk2.cyan("Category"),
+        chalk2.cyan("Price"),
+        chalk2.cyan("Rating"),
+        chalk2.cyan("Sales")
+      ],
+      style: { head: [], border: ["gray"] },
+      colWidths: [14, 30, 14, 10, 10, 8]
+    });
+    for (const prompt2 of items) {
+      const price = parseFloat(prompt2.currentPrice);
+      const rating = parseFloat(prompt2.averageRating);
+      table.push([
+        chalk2.bold(prompt2.ticker),
+        prompt2.title.length > 28 ? prompt2.title.slice(0, 25) + "..." : prompt2.title,
+        prompt2.category,
+        chalk2.green(`$${price.toFixed(2)}`),
+        rating > 0 ? chalk2.yellow(`\u2605 ${rating.toFixed(1)}`) : chalk2.gray("\u2014"),
+        prompt2.salesCount.toString()
+      ]);
+    }
+    console.log(table.toString());
+    console.log(
+      chalk2.gray("\n  Get details: ") + chalk2.white("plexmint info <TICKER>") + chalk2.gray("  |  Install: ") + chalk2.white("plexmint install <TICKER>\n")
+    );
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      console.error(chalk2.red(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(chalk2.red("\n  Connection error. Is plexmint.com reachable?\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/info.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function infoCommand(ticker) {
+  const spinner = ora3(`Looking up ${ticker.toUpperCase()}...`).start();
+  try {
+    const client = new PlexMintClient(getApiKey(), getBaseUrl());
+    const result = await client.getPrompt(ticker);
+    spinner.stop();
+    const p = result.data;
+    const price = parseFloat(p.currentPrice);
+    const rating = parseFloat(p.averageRating);
+    console.log("");
+    console.log(chalk3.bold.white(`  ${p.title}`));
+    console.log(chalk3.gray(`  ${p.ticker}`) + chalk3.gray(` \xB7 ${p.category}`));
+    console.log("");
+    console.log(chalk3.white(`  ${p.description}`));
+    console.log("");
+    console.log(
+      chalk3.green.bold(`  $${price.toFixed(2)}`) + chalk3.gray("  \xB7  ") + (rating > 0 ? chalk3.yellow(`\u2605 ${rating.toFixed(1)}`) : chalk3.gray("No ratings")) + chalk3.gray("  \xB7  ") + chalk3.white(`${p.salesCount} sold`) + chalk3.gray("  \xB7  ") + chalk3.white(`${p.reviewCount} reviews`)
+    );
+    console.log("");
+    if (p.models.length > 0) {
+      const modelList = p.models.map((m) => m.isPrimary ? chalk3.cyan.bold(m.model) : chalk3.gray(m.model)).join(", ");
+      console.log(chalk3.gray("  Models: ") + modelList);
+    }
+    if (p.tags && p.tags.length > 0) {
+      console.log(
+        chalk3.gray("  Tags: ") + p.tags.map((t) => chalk3.gray(`#${t}`)).join(" ")
+      );
+    }
+    if (p.seller) {
+      console.log(
+        chalk3.gray("  Seller: ") + chalk3.white(p.seller.name || p.seller.username || "\u2014") + (p.seller.username ? chalk3.gray(` (@${p.seller.username})`) : "")
+      );
+    }
+    if (p.tokenEstimate) {
+      console.log(chalk3.gray(`  Tokens: ~${p.tokenEstimate}`));
+    }
+    console.log("");
+    console.log(chalk3.gray("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+    console.log(
+      chalk3.gray("  \u2502 ") + chalk3.white("Install:") + chalk3.gray("                                \u2502")
+    );
+    const installCmd = `npx plexmint install ${p.ticker}`;
+    const padding = 39 - installCmd.length;
+    console.log(
+      chalk3.gray("  \u2502 ") + chalk3.cyan.bold(installCmd) + " ".repeat(Math.max(0, padding)) + chalk3.gray("\u2502")
+    );
+    console.log(chalk3.gray("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+    console.log(
+      chalk3.gray("\n  View on web: ") + chalk3.underline(`https://plexmint.com/prompt/${p.slug}
+`)
+    );
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      if (error.status === 404) {
+        console.error(
+          chalk3.red(`
+  Prompt not found: ${ticker.toUpperCase()}
+`)
+        );
+      } else {
+        console.error(chalk3.red(`
+  Error: ${error.message}
+`));
+      }
+    } else {
+      console.error(chalk3.red("\n  Connection error. Is plexmint.com reachable?\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/install.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, resolve } from "path";
+async function installCommand(ticker, options) {
+  const upperTicker = ticker.toUpperCase();
+  if (!isAuthenticated()) {
+    console.log("");
+    console.log(
+      chalk4.yellow("  Authentication required to install prompts.")
+    );
+    console.log(
+      chalk4.gray("  Run: ") + chalk4.white("plexmint login") + chalk4.gray(" first\n")
+    );
+    process.exit(1);
+  }
+  const spinner = ora4(`Looking up ${upperTicker}...`).start();
+  try {
+    const client = new PlexMintClient(getApiKey(), getBaseUrl());
+    let content;
+    try {
+      content = await client.getContent(upperTicker);
+      spinner.text = `Downloading ${upperTicker}...`;
+    } catch (error) {
+      if (error instanceof PlexMintApiError && error.status === 403) {
+        spinner.stop();
+        const info = await client.getPrompt(upperTicker);
+        const p = info.data;
+        const price = parseFloat(p.currentPrice);
+        console.log("");
+        console.log(
+          chalk4.yellow(`  You haven't purchased ${upperTicker} yet.`)
+        );
+        console.log("");
+        console.log(
+          chalk4.white(`  ${p.title}`) + chalk4.gray(` by ${p.seller?.username || "unknown"}`)
+        );
+        console.log(chalk4.green.bold(`  $${price.toFixed(2)}`));
+        console.log("");
+        const purchaseSpinner = ora4("Locking price...").start();
+        try {
+          const purchase = await client.purchase(upperTicker);
+          purchaseSpinner.stop();
+          console.log(
+            chalk4.green(`  Price locked at $${purchase.data.lockedPrice} for ${purchase.data.lockDurationSeconds}s`)
+          );
+          console.log("");
+          console.log(
+            chalk4.white("  Complete your purchase here:")
+          );
+          console.log(
+            chalk4.cyan.underline(`  ${purchase.data.checkoutUrl}`)
+          );
+          console.log("");
+          console.log(
+            chalk4.gray(
+              "  After purchasing, run this command again to download.\n"
+            )
+          );
+        } catch (purchaseError) {
+          purchaseSpinner.stop();
+          if (purchaseError instanceof PlexMintApiError) {
+            if (purchaseError.status === 409) {
+              console.log(
+                chalk4.yellow("  You already own this prompt. Retrying download...\n")
+              );
+              content = await client.getContent(upperTicker);
+            } else {
+              console.error(chalk4.red(`
+  Purchase error: ${purchaseError.message}
+`));
+              process.exit(1);
+            }
+          } else {
+            throw purchaseError;
+          }
+        }
+        if (!content) return;
+      } else {
+        throw error;
+      }
+    }
+    spinner.stop();
+    const data = content.data;
+    const installDir = resolve(options.dir || ".plexmint");
+    if (!existsSync(installDir)) {
+      mkdirSync(installDir, { recursive: true });
+    }
+    const promptDir = join(installDir, data.ticker.toLowerCase());
+    if (!existsSync(promptDir)) {
+      mkdirSync(promptDir, { recursive: true });
+    }
+    const promptFile = join(promptDir, "prompt.md");
+    if (existsSync(promptFile) && !options.force) {
+      console.log(
+        chalk4.yellow(
+          `
+  ${upperTicker} is already installed. Use --force to overwrite.
+`
+        )
+      );
+      return;
+    }
+    writeFileSync(promptFile, data.promptText, "utf-8");
+    const metaFile = join(promptDir, "plexmint.json");
+    writeFileSync(
+      metaFile,
+      JSON.stringify(
+        {
+          ticker: data.ticker,
+          title: data.title,
+          version: data.version,
+          variables: data.variables,
+          tips: data.tips,
+          models: data.models,
+          tokenEstimate: data.tokenEstimate,
+          costPerCall: data.costPerCall,
+          exampleInput: data.exampleInput,
+          exampleOutput: data.exampleOutput,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+    console.log("");
+    console.log(chalk4.green.bold(`  \u2713 Installed ${data.ticker}`));
+    console.log(chalk4.gray(`    ${data.title} v${data.version}`));
+    console.log("");
+    console.log(chalk4.gray("  Files:"));
+    console.log(chalk4.white(`    ${promptFile}`) + chalk4.gray(" \u2014 prompt text"));
+    console.log(chalk4.white(`    ${metaFile}`) + chalk4.gray(" \u2014 metadata"));
+    if (data.variables && data.variables.length > 0) {
+      console.log("");
+      console.log(chalk4.gray("  Variables:"));
+      for (const v of data.variables) {
+        console.log(chalk4.cyan(`    {{${v}}}`));
+      }
+    }
+    if (data.tips) {
+      console.log("");
+      console.log(chalk4.gray("  Tips: ") + chalk4.white(data.tips));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      if (error.status === 404) {
+        console.error(chalk4.red(`
+  Prompt not found: ${upperTicker}
+`));
+      } else {
+        console.error(chalk4.red(`
+  Error: ${error.message}
+`));
+      }
+    } else {
+      console.error(chalk4.red("\n  Connection error. Is plexmint.com reachable?\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/login.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+import { createInterface } from "readline";
+function prompt(question, hide = false) {
+  return new Promise((resolve2) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hide) {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve2(answer);
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve2(answer);
+      });
+    }
+  });
+}
+async function loginCommand(options) {
+  console.log("");
+  console.log(chalk5.bold("  PlexMint Login"));
+  console.log(chalk5.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log("");
+  if (options.apiKey) {
+    setApiKey(options.apiKey);
+    console.log(chalk5.green("  \u2713 API key saved."));
+    console.log(chalk5.gray(`  Config: ${getConfigPath()}
+`));
+    return;
+  }
+  if (isAuthenticated()) {
+    const answer = await prompt(
+      chalk5.yellow("  Already logged in. Re-authenticate? (y/N) ")
+    );
+    if (answer.toLowerCase() !== "y") {
+      console.log(chalk5.gray("  Cancelled.\n"));
+      return;
+    }
+    clearAuth();
+  }
+  console.log(
+    chalk5.gray(
+      "  Enter your PlexMint credentials to authenticate.\n  Your API key will be stored locally.\n"
+    )
+  );
+  const email = await prompt(chalk5.white("  Email: "));
+  const password = await prompt(chalk5.white("  Password: "));
+  if (!email || !password) {
+    console.log(chalk5.red("\n  Email and password are required.\n"));
+    process.exit(1);
+  }
+  const spinner = ora5("Authenticating...").start();
+  try {
+    const client = new PlexMintClient(null, getBaseUrl());
+    const result = await client.authenticate(email, password);
+    spinner.stop();
+    const { user, hasApiKey } = result.data;
+    if (hasApiKey) {
+      console.log(chalk5.green(`
+  \u2713 Authenticated as ${user.username || user.email}`));
+      console.log("");
+      console.log(
+        chalk5.white("  Enter your API key") + chalk5.gray(" (from Settings > API Keys):")
+      );
+      const key = await prompt(chalk5.white("  API Key: "));
+      if (!key) {
+        console.log(chalk5.red("\n  API key is required.\n"));
+        process.exit(1);
+      }
+      setApiKey(key);
+      setUserInfo(user.username || "", email);
+      console.log(chalk5.green("\n  \u2713 Logged in successfully!"));
+      console.log(chalk5.gray(`  User: ${user.username || user.email}`));
+      console.log(chalk5.gray(`  Config: ${getConfigPath()}
+`));
+    } else {
+      console.log(chalk5.yellow(`
+  \u2713 Credentials verified for ${user.email}`));
+      console.log(
+        chalk5.yellow(
+          "  No API key found. Generate one at https://plexmint.com/settings"
+        )
+      );
+      console.log(
+        chalk5.gray(
+          "\n  After generating a key, run: " + chalk5.white("plexmint login --api-key <YOUR_KEY>\n")
+        )
+      );
+      setUserInfo(user.username || "", email);
+    }
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      if (error.status === 401) {
+        console.error(chalk5.red("\n  Invalid email or password.\n"));
+      } else {
+        console.error(chalk5.red(`
+  Error: ${error.message}
+`));
+      }
+    } else {
+      console.error(
+        chalk5.red("\n  Connection error. Is plexmint.com reachable?\n")
+      );
+    }
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  clearAuth();
+  console.log(chalk5.green("\n  \u2713 Logged out. API key removed.\n"));
+}
+
+// src/commands/library.ts
+import chalk6 from "chalk";
+import ora6 from "ora";
+async function libraryCommand() {
+  if (!isAuthenticated()) {
+    console.log("");
+    console.log(chalk6.yellow("  Authentication required to view your library."));
+    console.log(
+      chalk6.gray("  Run: ") + chalk6.white("plexmint login") + chalk6.gray(" first\n")
+    );
+    process.exit(1);
+  }
+  const spinner = ora6("Loading your library...").start();
+  try {
+    const client = new PlexMintClient(getApiKey(), getBaseUrl());
+    spinner.stop();
+    console.log("");
+    console.log(chalk6.bold("  Your Library"));
+    console.log(chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log("");
+    console.log(
+      chalk6.gray(
+        "  View your purchased prompts at: "
+      ) + chalk6.cyan.underline("https://plexmint.com/library")
+    );
+    console.log("");
+    console.log(
+      chalk6.gray("  To download a purchased prompt locally:")
+    );
+    console.log(chalk6.white("  plexmint install <TICKER>\n"));
+  } catch (error) {
+    spinner.stop();
+    if (error instanceof PlexMintApiError) {
+      console.error(chalk6.red(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(chalk6.red("\n  Connection error.\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+var BANNER = `
+  ${chalk7.bold.cyan("plex")}${chalk7.bold.green("mint")} ${chalk7.gray("\u2014 AI prompts that evolve")}
+  ${chalk7.gray("https://plexmint.com")}
+`;
+program.name("plexmint").description("Browse, install, and manage AI prompts from the PlexMint marketplace").version("0.1.0").addHelpText("before", BANNER);
+program.command("search <query>").description("Search for prompts by keyword").option("-c, --category <category>", "Filter by category (business, writing, code, seo, design, education, data, social-media, personal)").option("-m, --model <model>", "Filter by AI model (gpt-4o, claude-opus, claude-sonnet, gemini, midjourney, etc.)").option("-s, --sort <sort>", "Sort order (trending, top_rated, most_sales, newest, price_low, price_high)", "trending").option("-l, --limit <limit>", "Number of results (max 100)", "12").action(searchCommand);
+program.command("browse").description("Browse the PlexMint marketplace").option("-c, --category <category>", "Filter by category").option("-m, --model <model>", "Filter by AI model").option("-s, --sort <sort>", "Sort order", "trending").option("-l, --limit <limit>", "Number of results", "20").action(browseCommand);
+program.command("info <ticker>").description("Get detailed info about a prompt by its ticker symbol").action(infoCommand);
+program.command("install <ticker>").description("Install a prompt locally (downloads to .plexmint/ directory)").option("-d, --dir <directory>", "Install directory (default: .plexmint)").option("-f, --force", "Overwrite if already installed").action(installCommand);
+program.command("login").description("Authenticate with your PlexMint account").option("--api-key <key>", "Set API key directly (skip interactive login)").action(loginCommand);
+program.command("logout").description("Remove stored API key").action(logoutCommand);
+program.command("library").description("View your purchased prompts").action(libraryCommand);
+program.action(() => {
+  console.log(BANNER);
+  console.log(chalk7.bold("  Quick Start:"));
+  console.log("");
+  console.log(chalk7.gray("    Browse marketplace    ") + chalk7.white("plexmint browse"));
+  console.log(chalk7.gray("    Search prompts        ") + chalk7.white('plexmint search "email copywriting"'));
+  console.log(chalk7.gray("    Get prompt details    ") + chalk7.white("plexmint info NUE-SEO01"));
+  console.log(chalk7.gray("    Install a prompt      ") + chalk7.white("plexmint install NUE-SEO01"));
+  console.log(chalk7.gray("    Login to your account ") + chalk7.white("plexmint login"));
+  console.log("");
+  console.log(chalk7.gray("  Run ") + chalk7.white("plexmint --help") + chalk7.gray(" for all commands.\n"));
+});
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "plexmint",
+  "version": "0.1.0",
+  "description": "PlexMint CLI — Browse, install, and manage AI prompts from your terminal",
+  "type": "module",
+  "bin": {
+    "plexmint": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "prompts",
+    "marketplace",
+    "agent",
+    "cli",
+    "living-prompts",
+    "plexmint"
+  ],
+  "author": "PlexMint <info@plexmint.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nuesion/plexmint.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://plexmint.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "conf": "^13.1.0",
+    "ora": "^8.2.0",
+    "cli-table3": "^0.6.5"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "@types/node": "^20.0.0"
+  }
+}