opencode-marketplace 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-marketplace",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI marketplace for OpenCode plugins",
   "type": "module",
   "author": "nikiforovall",
@@ -44,6 +44,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
     "cac": "^6.7.14"
   }
 }

package/src/cli.ts

@@ -13,6 +13,7 @@ export function run(argv = process.argv) {
     .command("install <path>", "Install a plugin from a local directory or GitHub URL")
     .option("--scope <scope>", "Installation scope (user/project)", { default: "user" })
     .option("--force", "Overwrite existing components", { default: false })
+    .option("-i, --interactive", "Interactively select components to install", { default: false })
     .action((path, options) => {
       if (options.scope !== "user" && options.scope !== "project") {
         console.error(`Invalid scope: ${options.scope}. Must be 'user' or 'project'.`);

package/src/commands/install.ts

@@ -5,9 +5,9 @@ import { discoverComponents } from "../discovery";
 import { formatComponentCount } from "../format";
 import { cleanup, cloneToTemp } from "../git";
 import { isGitHubUrl, parseGitHubUrl } from "../github";
-import { computePluginHash, resolvePluginName } from "../identity";
 import { ensureComponentDirsExist, getComponentTargetPath } from "../paths";
 import { getInstalledPlugin, loadRegistry, saveRegistry } from "../registry";
+import { computePluginHash, inferPluginName } from "../resolution";
 import type {
   ComponentType,
   DiscoveredComponent,
@@ -15,12 +15,12 @@ import type {
   PluginSource,
   Scope,
 } from "../types";
-import { validatePluginName } from "../types";
 
 export interface InstallOptions {
   scope: "user" | "project";
   force: boolean;
   verbose?: boolean;
+  interactive?: boolean;
 }
 
 interface ConflictInfo {
@@ -30,7 +30,7 @@ interface ConflictInfo {
 }
 
 export async function install(path: string, options: InstallOptions) {
-  const { scope, force, verbose } = options;
+  const { scope, force, verbose, interactive } = options;
 
   let tempDir: string | null = null;
   let pluginSource: PluginSource;
@@ -78,27 +78,11 @@ export async function install(path: string, options: InstallOptions) {
       };
     }
 
-    // Step 2: Resolve plugin identity
-    // For remote installations, derive name from URL instead of temp directory
-    let pluginName: string;
-    if (pluginSource.type === "remote") {
-      const parsed = parseGitHubUrl(path);
-      if (!parsed) {
-        throw new Error(`Invalid GitHub URL: ${path}`);
-      }
-      // Use subpath if present (e.g., "foo" from "plugins/foo"), otherwise use repo name
-      const lastPathPart = parsed.subpath?.split("/").filter(Boolean).pop();
-      pluginName = (lastPathPart || parsed.repo).toLowerCase();
-
-      // Validate the derived name
-      if (!validatePluginName(pluginName)) {
-        throw new Error(
-          `Invalid plugin name "${pluginName}" derived from URL. Plugin names must be lowercase alphanumeric with hyphens.`,
-        );
-      }
-    } else {
-      pluginName = resolvePluginName(pluginPath);
-    }
+    // Step 2: Resolve plugin identity using unified logic
+    const pluginName = await inferPluginName(
+      pluginPath,
+      pluginSource.type === "remote" ? path : undefined,
+    );
 
     if (verbose) {
       console.log(`[VERBOSE] Resolved plugin name: ${pluginName}`);
@@ -112,6 +96,44 @@ export async function install(path: string, options: InstallOptions) {
       );
     }
 
+    // Step 3.5: Interactive selection (if enabled)
+    let componentsToInstall = components;
+
+    if (interactive) {
+      const { selectComponents } = await import("../interactive");
+
+      try {
+        const result = await selectComponents(pluginName, components);
+
+        if (result.cancelled) {
+          console.log("\nInstallation cancelled.");
+          if (tempDir) {
+            await cleanup(tempDir);
+          }
+          return;
+        }
+
+        if (result.selected.length === 0) {
+          console.log("No components selected. Nothing installed.");
+          if (tempDir) {
+            await cleanup(tempDir);
+          }
+          return;
+        }
+
+        componentsToInstall = result.selected;
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("User force closed")) {
+          console.log("\nInstallation cancelled.");
+          if (tempDir) {
+            await cleanup(tempDir);
+          }
+          return;
+        }
+        throw error;
+      }
+    }
+
     // Step 4: Compute plugin hash
     const pluginHash = await computePluginHash(components);
     const shortHash = pluginHash.substring(0, 8);
@@ -119,6 +141,11 @@ export async function install(path: string, options: InstallOptions) {
     if (verbose) {
       console.log(`[VERBOSE] Plugin hash: ${pluginHash}`);
       console.log(`[VERBOSE] Found ${components.length} component(s)`);
+      if (interactive && componentsToInstall.length < components.length) {
+        console.log(
+          `[VERBOSE] Selected ${componentsToInstall.length} component(s) for installation`,
+        );
+      }
     }
 
     console.log(`Installing ${pluginName} [${shortHash}]...`);
@@ -143,7 +170,7 @@ export async function install(path: string, options: InstallOptions) {
     }
 
     // Step 6: Detect conflicts
-    const conflicts = await detectConflicts(components, pluginName, scope);
+    const conflicts = await detectConflicts(componentsToInstall, pluginName, scope);
 
     if (conflicts.length > 0 && !force) {
       console.error("\nConflict detected:");
@@ -177,7 +204,7 @@ export async function install(path: string, options: InstallOptions) {
     };
 
     // Sort components by name to ensure deterministic installation order and registry entry
-    const sortedComponents = [...components].sort((a, b) => a.name.localeCompare(b.name));
+    const sortedComponents = [...componentsToInstall].sort((a, b) => a.name.localeCompare(b.name));
 
     for (const component of sortedComponents) {
       const targetPath = getComponentTargetPath(pluginName, component.name, component.type, scope);

package/src/commands/scan.ts

@@ -3,9 +3,8 @@ import { resolve } from "node:path";
 import { discoverComponents } from "../discovery";
 import { cleanup, cloneToTemp } from "../git";
 import { isGitHubUrl, parseGitHubUrl } from "../github";
-import { computePluginHash, resolvePluginName } from "../identity";
+import { computePluginHash, inferPluginName } from "../resolution";
 import type { DiscoveredComponent } from "../types";
-import { validatePluginName } from "../types";
 
 export interface ScanOptions {
   verbose?: boolean;
@@ -55,28 +54,10 @@ export async function scan(path: string, options: ScanOptions): Promise<void> {
       }
     }
 
-    // 2. Resolve plugin identity
+    // 2. Resolve plugin identity using unified logic
     let pluginName: string;
     try {
-      // For remote scans, derive name from URL instead of temp directory
-      if (isGitHubUrl(path)) {
-        const parsed = parseGitHubUrl(path);
-        if (!parsed) {
-          throw new Error(`Invalid GitHub URL: ${path}`);
-        }
-        // Use subpath if present (e.g., "foo" from "plugins/foo"), otherwise use repo name
-        const lastPathPart = parsed.subpath?.split("/").filter(Boolean).pop();
-        pluginName = (lastPathPart || parsed.repo).toLowerCase();
-
-        // Validate the derived name
-        if (!validatePluginName(pluginName)) {
-          throw new Error(
-            `Invalid plugin name "${pluginName}" derived from URL. Plugin names must be lowercase alphanumeric with hyphens.`,
-          );
-        }
-      } else {
-        pluginName = resolvePluginName(absolutePath);
-      }
+      pluginName = await inferPluginName(absolutePath, isGitHubUrl(path) ? path : undefined);
 
       if (options.verbose) {
         console.log(`[VERBOSE] Resolved plugin name: ${pluginName}`);

package/src/commands/update.ts

@@ -1,8 +1,8 @@
 import { discoverComponents } from "../discovery";
 import { cleanup, cloneToTemp } from "../git";
 import { parseGitHubUrl } from "../github";
-import { computePluginHash } from "../identity";
 import { getInstalledPlugin } from "../registry";
+import { computePluginHash } from "../resolution";
 import { install } from "./install";
 
 export interface UpdateOptions {

package/src/interactive.ts

@@ -0,0 +1,105 @@
+import { checkbox, Separator } from "@inquirer/prompts";
+import type { DiscoveredComponent } from "./types";
+
+export interface SelectionResult {
+  selected: DiscoveredComponent[];
+  cancelled: boolean;
+}
+
+/**
+ * Presents an interactive multi-select UI for choosing components to install
+ * @param pluginName - Name of the plugin being installed
+ * @param components - All discovered components
+ * @returns Selected components or empty array if cancelled/nothing selected
+ * @throws Error if not running in a TTY
+ */
+export async function selectComponents(
+  pluginName: string,
+  components: DiscoveredComponent[],
+): Promise<SelectionResult> {
+  // Check TTY
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive mode requires a terminal");
+  }
+
+  // Group by type
+  const grouped = groupByType(components);
+
+  // Build choices with separators
+  const choices = buildChoices(grouped);
+
+  if (choices.length === 0) {
+    return { selected: [], cancelled: false };
+  }
+
+  try {
+    const selected = await checkbox({
+      message: `Select components to install from "${pluginName}":`,
+      choices,
+      pageSize: 15,
+    });
+
+    return { selected, cancelled: false };
+  } catch (error) {
+    // Handle Ctrl+C gracefully
+    if (error instanceof Error && error.message.includes("User force closed")) {
+      return { selected: [], cancelled: true };
+    }
+    throw error;
+  }
+}
+
+interface GroupedComponents {
+  commands: DiscoveredComponent[];
+  agents: DiscoveredComponent[];
+  skills: DiscoveredComponent[];
+}
+
+/**
+ * Groups components by their type
+ */
+function groupByType(components: DiscoveredComponent[]): GroupedComponents {
+  return {
+    commands: components.filter((c) => c.type === "command"),
+    agents: components.filter((c) => c.type === "agent"),
+    skills: components.filter((c) => c.type === "skill"),
+  };
+}
+
+/**
+ * Builds inquirer choices with separators and proper formatting
+ */
+function buildChoices(
+  grouped: GroupedComponents,
+): Array<Separator | { name: string; value: DiscoveredComponent }> {
+  const choices: Array<Separator | { name: string; value: DiscoveredComponent }> = [];
+
+  if (grouped.commands.length > 0) {
+    if (choices.length > 0) choices.push(new Separator(""));
+    choices.push(new Separator(`\x1b[1m📋 Commands (${grouped.commands.length})\x1b[0m`));
+    choices.push(new Separator("─".repeat(50)));
+    for (const c of grouped.commands) {
+      choices.push({ name: `  ${c.name}`, value: c });
+    }
+  }
+
+  if (grouped.agents.length > 0) {
+    if (choices.length > 0) choices.push(new Separator(""));
+    choices.push(new Separator(`\x1b[1m🤖 Agents (${grouped.agents.length})\x1b[0m`));
+    choices.push(new Separator("─".repeat(50)));
+    for (const c of grouped.agents) {
+      choices.push({ name: `  ${c.name}`, value: c });
+    }
+  }
+
+  if (grouped.skills.length > 0) {
+    if (choices.length > 0) choices.push(new Separator(""));
+    choices.push(new Separator(`\x1b[1m🎯 Skills (${grouped.skills.length})\x1b[0m`));
+    choices.push(new Separator("─".repeat(50)));
+    for (const c of grouped.skills) {
+      choices.push({ name: `  ${c.name}/`, value: c });
+    }
+  }
+
+  return choices;
+}

package/src/manifest.ts

@@ -0,0 +1,33 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * Reads the plugin name from plugin.json if it exists.
+ * Returns null if plugin.json doesn't exist, is invalid, or missing name field.
+ *
+ * @param pluginPath - Absolute path to plugin directory
+ * @returns Plugin name from manifest or null
+ */
+export async function readPluginManifest(pluginPath: string): Promise<{ name: string } | null> {
+  const manifestPath = join(pluginPath, "plugin.json");
+
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+
+  try {
+    const content = await readFile(manifestPath, "utf-8");
+    const json = JSON.parse(content);
+
+    // Only extract name field
+    if (json.name && typeof json.name === "string") {
+      return { name: json.name };
+    }
+
+    return null;
+  } catch {
+    // Invalid JSON or read error
+    return null;
+  }
+}

package/src/{identity.ts → resolution.ts}

@@ -1,8 +1,54 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { parseGitHubUrl } from "./github";
+import { readPluginManifest } from "./manifest";
 import { type DiscoveredComponent, validatePluginName } from "./types";
 
+/**
+ * Infers plugin name from multiple sources with priority:
+ * 1. plugin.json name field if present
+ * 2. Derived from GitHub URL (with dot-stripping)
+ * 3. Local directory name (with dot-stripping)
+ *
+ * @param pluginPath - Absolute path to plugin directory
+ * @param originalPath - Original path/URL provided by user (for remote sources)
+ * @returns Validated plugin name
+ */
+export async function inferPluginName(pluginPath: string, originalPath?: string): Promise<string> {
+  // Try reading plugin.json name field first
+  const manifest = await readPluginManifest(pluginPath);
+
+  if (manifest?.name) {
+    const name = manifest.name.toLowerCase();
+    if (!validatePluginName(name)) {
+      throw new Error(
+        `Invalid plugin name "${name}" in plugin.json. Plugin names must be lowercase alphanumeric with hyphens.`,
+      );
+    }
+    return name;
+  }
+
+  // For remote URLs, derive from URL with dot-stripping
+  if (originalPath?.startsWith("https://github.com/")) {
+    const parsed = parseGitHubUrl(originalPath);
+    if (parsed) {
+      const lastPathPart = parsed.subpath?.split("/").filter(Boolean).pop();
+      const name = (lastPathPart || parsed.repo).replace(/^\.+/, "").toLowerCase();
+
+      if (!validatePluginName(name)) {
+        throw new Error(
+          `Invalid plugin name "${name}" derived from URL. Plugin names must be lowercase alphanumeric with hyphens.`,
+        );
+      }
+      return name;
+    }
+  }
+
+  // Fallback to directory name
+  return resolvePluginName(pluginPath);
+}
+
 /**
  * Resolves the plugin name from the directory path.
  * Normalizes the name to be lowercase and validates it.
@@ -11,7 +57,8 @@ export function resolvePluginName(pluginPath: string): string {
   // Extract the last part of the path, handling both Windows and POSIX separators
   const parts = pluginPath.split(/[\\/]/);
   const lastPart = parts.filter(Boolean).pop() || "";
-  const name = lastPart.toLowerCase();
+  // Strip leading dots (e.g., .claude-plugin -> claude-plugin)
+  const name = lastPart.replace(/^\.+/, "").toLowerCase();
 
   if (!validatePluginName(name)) {
     throw new Error(