gsd-pi 2.20.0 → 2.22.0

package/src/resources/extensions/gsd/claude-import.ts

@@ -0,0 +1,656 @@
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { SettingsManager, getAgentDir } from "@gsd/pi-coding-agent";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { PluginImporter, type ImportManifestEntry } from "./plugin-importer.js";
+import type { NamespacedComponent } from "./namespaced-registry.js";
+
+export interface ClaudeSkillCandidate {
+  type: "skill";
+  name: string;
+  path: string;
+  root: string;
+  sourceLabel: string;
+}
+
+export interface ClaudePluginCandidate {
+  type: "plugin";
+  name: string;
+  path: string;
+  root: string;
+  sourceLabel: string;
+  packageName?: string;
+}
+
+const SKIP_DIRS = new Set([
+  ".git",
+  "node_modules",
+  ".worktrees",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "cache",
+  ".cache",
+]);
+
+function uniqueExistingDirs(paths: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const candidate of paths) {
+    const resolvedPath = resolve(candidate);
+    if (seen.has(resolvedPath)) continue;
+    seen.add(resolvedPath);
+    if (existsSync(resolvedPath)) out.push(resolvedPath);
+  }
+  return out;
+}
+
+export function getClaudeSearchRoots(cwd: string): { skillRoots: string[]; pluginRoots: string[] } {
+  const home = homedir();
+  const parent = resolve(cwd, "..");
+  const grandparent = resolve(cwd, "..", "..");
+
+  // Claude Code user-scope skills live under ~/.claude/skills.
+  // Keep sibling/local clone fallbacks for developer workflows, but they are
+  // examples/convenience paths rather than the primary Claude storage model.
+  const skillRoots = uniqueExistingDirs([
+    join(home, ".claude", "skills"),
+    join(home, "repos", "claude_skills"),
+    join(home, "repos", "skills"),
+    join(parent, "claude_skills"),
+    join(parent, "skills"),
+    join(grandparent, "claude_skills"),
+    join(grandparent, "skills"),
+  ]);
+
+  // Anthropic docs model marketplaces as sources users add with
+  // `/plugin marketplace add ...`, and Claude stores those marketplaces under
+  // ~/.claude/plugins/marketplaces/. Installed plugin payloads are copied into
+  // ~/.claude/plugins/cache/. We prefer those stable Claude-managed locations
+  // before local example clones.
+  const pluginRoots = uniqueExistingDirs([
+    join(home, ".claude", "plugins", "marketplaces"),
+    join(home, ".claude", "plugins", "cache"),
+    join(home, ".claude", "plugins"),
+    join(home, "repos", "claude-plugins-official"),
+    join(home, "repos", "claude_skills"),
+    join(parent, "claude-plugins-official"),
+    join(parent, "claude_skills"),
+    join(grandparent, "claude-plugins-official"),
+    join(grandparent, "claude_skills"),
+  ]);
+
+  return { skillRoots, pluginRoots };
+}
+
+function sourceLabel(path: string): string {
+  const home = homedir();
+  if (path.startsWith(join(home, ".claude"))) return "claude-home";
+  if (path.startsWith(join(home, "repos"))) return "repos";
+  return "local";
+}
+
+/**
+ * Check if a path is a marketplace directory (contains .claude-plugin/marketplace.json).
+ * Marketplace paths use the PluginImporter flow; non-marketplace use the legacy flat flow.
+ */
+function isMarketplacePath(pluginPath: string): boolean {
+  const marketplaceJson = join(pluginPath, ".claude-plugin", "marketplace.json");
+  return existsSync(marketplaceJson);
+}
+
+/**
+ * Detect which plugin roots are marketplaces and which are legacy flat paths.
+ */
+function categorizePluginRoots(pluginRoots: string[]): { marketplaces: string[]; flat: string[] } {
+  const marketplaces: string[] = [];
+  const flat: string[] = [];
+
+  for (const root of pluginRoots) {
+    if (isMarketplacePath(root)) {
+      marketplaces.push(root);
+    } else {
+      flat.push(root);
+    }
+  }
+
+  return { marketplaces, flat };
+}
+
+function walkDirs(root: string, visit: (dir: string, depth: number) => void, maxDepth = 4): void {
+  function walk(dir: string, depth: number) {
+    visit(dir, depth);
+    if (depth >= maxDepth) return;
+    let entries: Array<{ name: string; isDirectory: () => boolean }> = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      walk(join(dir, entry.name), depth + 1);
+    }
+  }
+  walk(root, 0);
+}
+
+export function discoverClaudeSkills(cwd: string): ClaudeSkillCandidate[] {
+  const { skillRoots } = getClaudeSearchRoots(cwd);
+  const results: ClaudeSkillCandidate[] = [];
+  const seen = new Set<string>();
+
+  for (const root of skillRoots) {
+    walkDirs(root, (dir) => {
+      const skillFile = join(dir, "SKILL.md");
+      if (!existsSync(skillFile)) return;
+      const resolvedDir = resolve(dir);
+      if (seen.has(resolvedDir)) return;
+      seen.add(resolvedDir);
+      results.push({
+        type: "skill",
+        name: basename(dir),
+        path: resolvedDir,
+        root,
+        sourceLabel: sourceLabel(root),
+      });
+    }, 5);
+  }
+
+  return results.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+}
+
+export function discoverClaudePlugins(cwd: string): ClaudePluginCandidate[] {
+  const { pluginRoots } = getClaudeSearchRoots(cwd);
+  const results: ClaudePluginCandidate[] = [];
+  const seen = new Set<string>();
+
+  for (const root of pluginRoots) {
+    walkDirs(root, (dir) => {
+      const pkgPath = join(dir, "package.json");
+      if (!existsSync(pkgPath)) return;
+      const resolvedDir = resolve(dir);
+      if (seen.has(resolvedDir)) return;
+      seen.add(resolvedDir);
+      let packageName: string | undefined;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { name?: string };
+        packageName = pkg.name;
+      } catch {
+        packageName = undefined;
+      }
+      results.push({
+        type: "plugin",
+        name: packageName || basename(dir),
+        packageName,
+        path: resolvedDir,
+        root,
+        sourceLabel: sourceLabel(root),
+      });
+    }, 4);
+  }
+
+  return results.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+}
+
+async function chooseMany<T extends { name: string; path: string; root: string; sourceLabel: string }>(
+  ctx: ExtensionCommandContext,
+  title: string,
+  candidates: T[],
+): Promise<T[]> {
+  if (candidates.length === 0) return [];
+
+  const mode = await ctx.ui.select(`${title} (${candidates.length} found)`, [
+    "Import all discovered",
+    "Select individually",
+    "Cancel",
+  ]);
+
+  if (!mode || mode === "Cancel") return [];
+  if (mode === "Import all discovered") return candidates;
+
+  const remaining = [...candidates];
+  const selected: T[] = [];
+  while (remaining.length > 0) {
+    const options = [
+      ...remaining.map((item) => `${item.name} — ${item.sourceLabel} — ${relative(item.root, item.path) || "."}`),
+      "Done selecting",
+    ];
+    const picked = await ctx.ui.select(`${title}: choose an item`, options);
+    if (!picked || picked === "Done selecting") break;
+    const pickedStr = Array.isArray(picked) ? picked[0] : picked;
+    if (!pickedStr) break;
+    const idx = options.indexOf(pickedStr);
+    if (idx < 0 || idx >= remaining.length) break;
+    selected.push(remaining[idx]!);
+    remaining.splice(idx, 1);
+  }
+  return selected;
+}
+
+function mergeStringList(existing: unknown, additions: string[]): string[] {
+  const list = Array.isArray(existing) ? existing.filter((v): v is string => typeof v === "string") : [];
+  const seen = new Set(list);
+  for (const item of additions) {
+    if (!seen.has(item)) {
+      list.push(item);
+      seen.add(item);
+    }
+  }
+  return list;
+}
+
+function mergePackageSources(existing: unknown, additions: string[]): Array<string | { source: string }> {
+  const current = Array.isArray(existing)
+    ? existing.filter((v): v is string | { source: string } => typeof v === "string" || (typeof v === "object" && v !== null && typeof (v as { source?: unknown }).source === "string"))
+    : [];
+
+  const seen = new Set(current.map((entry) => typeof entry === "string" ? entry : entry.source));
+  const merged = [...current];
+  for (const add of additions) {
+    if (!seen.has(add)) {
+      merged.push(add);
+      seen.add(add);
+    }
+  }
+  return merged;
+}
+
+// ============================================================================
+// Marketplace PluginImporter Integration (T02)
+// ============================================================================
+
+/**
+ * Component candidate from marketplace discovery.
+ * Extends NamespacedComponent with UI-friendly fields.
+ */
+interface MarketplaceComponentCandidate {
+  component: NamespacedComponent;
+  displayName: string;
+  pluginName: string;
+}
+
+/**
+ * Format a component for display in selection UI.
+ */
+function formatComponentForSelection(comp: NamespacedComponent): string {
+  const typeLabel = comp.type === 'skill' ? '🔧' : '🤖';
+  const nsLabel = comp.namespace ? `${comp.namespace}:` : '';
+  return `${typeLabel} ${nsLabel}${comp.name}`;
+}
+
+/**
+ * Present marketplace components for user selection, grouped by plugin.
+ * Returns the selected components for import.
+ */
+async function selectMarketplaceComponents(
+  ctx: ExtensionCommandContext,
+  importer: PluginImporter,
+  scope: "global" | "project"
+): Promise<NamespacedComponent[]> {
+  const plugins = importer.getDiscoveredPlugins();
+
+  if (plugins.length === 0) {
+    ctx.ui.notify("No plugins discovered in marketplace.", "info");
+    return [];
+  }
+
+  // Build component candidates grouped by plugin
+  const allComponents: MarketplaceComponentCandidate[] = [];
+  for (const plugin of plugins) {
+    const components = importer.selectComponents(c => c.namespace === plugin.canonicalName);
+    for (const comp of components) {
+      allComponents.push({
+        component: comp,
+        displayName: formatComponentForSelection(comp),
+        pluginName: plugin.canonicalName,
+      });
+    }
+  }
+
+  if (allComponents.length === 0) {
+    ctx.ui.notify("No components (skills/agents) found in marketplace plugins.", "info");
+    return [];
+  }
+
+  // Ask user for selection mode
+  const mode = await ctx.ui.select(
+    `Marketplace components → ${scope} config (${allComponents.length} found across ${plugins.length} plugins)`,
+    [
+      "Import all components",
+      "Select by plugin",
+      "Select individually",
+      "Cancel",
+    ]
+  );
+
+  if (!mode || mode === "Cancel") return [];
+
+  if (mode === "Import all components") {
+    return allComponents.map(c => c.component);
+  }
+
+  if (mode === "Select by plugin") {
+    // Let user select plugins, then import all their components
+    const pluginNames = plugins.map(p => p.canonicalName);
+    const selectedPluginNames: string[] = [];
+
+    while (true) {
+      const remaining = pluginNames.filter(n => !selectedPluginNames.includes(n));
+      if (remaining.length === 0) break;
+
+      const options = [...remaining, "Done selecting"];
+      const picked = await ctx.ui.select("Select a plugin to import all its components", options);
+
+      if (!picked || picked === "Done selecting") break;
+      const pickedStr = Array.isArray(picked) ? picked[0] : picked;
+      if (!pickedStr) break;
+      selectedPluginNames.push(pickedStr);
+    }
+
+    return allComponents
+      .filter(c => selectedPluginNames.includes(c.pluginName))
+      .map(c => c.component);
+  }
+
+  // Select individually
+  const remaining = [...allComponents];
+  const selected: NamespacedComponent[] = [];
+
+  while (remaining.length > 0) {
+    const options = remaining.map(c =>
+      `${c.displayName} — ${c.pluginName}`
+    );
+    options.push("Done selecting");
+
+    const picked = await ctx.ui.select("Select a component to import", options);
+    if (!picked || picked === "Done selecting") break;
+    const pickedStr = Array.isArray(picked) ? picked[0] : picked;
+    if (!pickedStr) break;
+
+    const idx = options.indexOf(pickedStr);
+    if (idx < 0 || idx >= remaining.length) break;
+
+    selected.push(remaining[idx]!.component);
+    remaining.splice(idx, 1);
+  }
+
+  return selected;
+}
+
+/**
+ * Format diagnostics for display to user.
+ * Returns a human-readable summary string.
+ */
+function formatDiagnosticsForUser(
+  diagnostics: Array<{ severity: string; class: string; remediation: string; involvedCanonicalNames: string[] }>
+): string {
+  const lines: string[] = [];
+
+  const errors = diagnostics.filter(d => d.severity === 'error');
+  const warnings = diagnostics.filter(d => d.severity === 'warning');
+
+  if (errors.length > 0) {
+    lines.push(`❌ ${errors.length} error(s) blocking import:`);
+    for (const err of errors) {
+      lines.push(`   - ${err.class}: ${err.involvedCanonicalNames.join(', ')}`);
+      lines.push(`     ${err.remediation}`);
+    }
+  }
+
+  if (warnings.length > 0) {
+    lines.push(`⚠️ ${warnings.length} warning(s):`);
+    for (const warn of warnings) {
+      lines.push(`   - ${warn.class}: ${warn.involvedCanonicalNames.join(', ')}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Persist import manifest entries to settings.
+ * Maps manifest entries to the appropriate settings format.
+ */
+function persistManifestToSettings(
+  manifestEntries: ImportManifestEntry[],
+  settingsManager: SettingsManager,
+  scope: "global" | "project"
+): void {
+  // Group entries by namespace for organized persistence
+  const skillPaths = manifestEntries
+    .filter(e => e.type === 'skill')
+    .map(e => e.filePath);
+
+  const agentPaths = manifestEntries
+    .filter(e => e.type === 'agent')
+    .map(e => e.filePath);
+
+  // For marketplace plugins, we also want to store plugin-level metadata
+  // Currently this adds component paths to skills/agents lists
+  // Future enhancement: store canonical names with metadata
+
+  if (skillPaths.length > 0) {
+    if (scope === "project") {
+      settingsManager.setProjectSkillPaths(
+        mergeStringList(settingsManager.getProjectSettings().skills, skillPaths)
+      );
+    } else {
+      settingsManager.setSkillPaths(
+        mergeStringList(settingsManager.getGlobalSettings().skills, skillPaths)
+      );
+    }
+  }
+
+  // Do not persist imported marketplace agents into settings.packages.
+  // Claude plugin agent directories contain markdown agent definitions, not loadable Pi
+  // extension packages. Writing `.../agents` paths into packages makes startup treat
+  // them as extension roots and produces module-load errors.
+  //
+  // For now, marketplace agents remain discoverable via the import manifest and
+  // canonical metadata, but are not persisted into package sources.
+}
+
+
+export async function runClaudeImportFlow(
+  ctx: ExtensionCommandContext,
+  scope: "global" | "project",
+  readPrefs: () => Record<string, unknown>,
+  writePrefs: (prefs: Record<string, unknown>) => Promise<void>,
+): Promise<void> {
+  const cwd = process.cwd();
+  const settingsManager = SettingsManager.create(cwd, getAgentDir());
+  const { skillRoots, pluginRoots } = getClaudeSearchRoots(cwd);
+
+  // Categorize plugin roots into marketplaces vs flat paths
+  const { marketplaces, flat } = categorizePluginRoots(pluginRoots);
+
+  // Determine import mode
+  const assetChoice = await ctx.ui.select("Import Claude assets into GSD/Pi config", [
+    "Skills + plugins",
+    "Skills only",
+    "Plugins only",
+    "Cancel",
+  ]);
+  if (!assetChoice || assetChoice === "Cancel") return;
+
+  const importSkills = assetChoice !== "Plugins only";
+  const importPlugins = assetChoice !== "Skills only";
+
+  // Track what we're importing
+  let importedSkillsCount = 0;
+  let importedPluginsCount = 0;
+  let importedMarketplaceComponents = 0;
+  const canonicalNamesPersisted: string[] = [];
+
+  // ========== SKILLS (legacy flat flow) ==========
+  if (importSkills) {
+    const discoveredSkills = discoverClaudeSkills(cwd);
+    const selectedSkills = await chooseMany(ctx, `Claude skills → ${scope} preferences`, discoveredSkills);
+
+    if (selectedSkills.length > 0) {
+      const prefMode = await ctx.ui.select("How should GSD treat the imported skills?", [
+        "Always use when relevant",
+        "Prefer when relevant",
+        "Do not modify skill preferences",
+      ]);
+
+      const prefs = readPrefs();
+      const skillPaths = selectedSkills.map((skill) => skill.path);
+      if (prefMode === "Always use when relevant") {
+        prefs.always_use_skills = mergeStringList(prefs.always_use_skills, skillPaths);
+      } else if (prefMode === "Prefer when relevant") {
+        prefs.prefer_skills = mergeStringList(prefs.prefer_skills, skillPaths);
+      }
+
+      await writePrefs(prefs);
+
+      if (scope === "project") {
+        settingsManager.setProjectSkillPaths(mergeStringList(settingsManager.getProjectSettings().skills, skillPaths));
+      } else {
+        settingsManager.setSkillPaths(mergeStringList(settingsManager.getGlobalSettings().skills, skillPaths));
+      }
+
+      importedSkillsCount = selectedSkills.length;
+    }
+  }
+
+  // ========== MARKETPLACE PLUGINS (new PluginImporter flow) ==========
+  if (importPlugins && marketplaces.length > 0) {
+    const marketplaceChoice = await ctx.ui.select(
+      `Found ${marketplaces.length} marketplace(s). Import from marketplace?`,
+      [
+        "Yes - discover plugins and select components",
+        "Skip marketplaces (use legacy plugin paths only)",
+        "Cancel",
+      ]
+    );
+
+    if (marketplaceChoice === "Yes - discover plugins and select components") {
+      // Instantiate PluginImporter and discover
+      const importer = new PluginImporter();
+      const discovery = importer.discover(marketplaces);
+
+      if (discovery.summary.totalPlugins > 0) {
+        // Present components for selection
+        const selectedComponents = await selectMarketplaceComponents(ctx, importer, scope);
+
+        if (selectedComponents.length > 0) {
+          // Run validation (pre-import diagnostics)
+          const validation = importer.validateImport(selectedComponents);
+
+          // Show diagnostics
+          if (validation.diagnostics.length > 0) {
+            const diagMessage = formatDiagnosticsForUser(validation.diagnostics);
+            ctx.ui.notify(diagMessage, validation.canProceed ? "warning" : "error");
+
+            // Block if errors exist
+            if (!validation.canProceed) {
+              ctx.ui.notify(
+                "Import blocked due to canonical name conflicts. Please resolve the errors above.",
+                "error"
+              );
+              return;
+            }
+
+            // Warn but allow proceed for warnings
+            const proceed = await ctx.ui.select(
+              "Warnings detected. Continue with import?",
+              ["Yes, continue", "Cancel"]
+            );
+            if (proceed !== "Yes, continue") {
+              return;
+            }
+          }
+
+          // Generate manifest and persist
+          const manifest = importer.getImportManifest(selectedComponents);
+          persistManifestToSettings(manifest.entries, settingsManager, scope);
+
+          importedMarketplaceComponents = selectedComponents.length;
+          canonicalNamesPersisted.push(...manifest.entries.map(e => e.canonicalName));
+        }
+      } else {
+        ctx.ui.notify(`No plugins discovered in ${marketplaces.length} marketplace(s).`, "info");
+      }
+    }
+  }
+
+  // ========== FLAT PLUGIN PATHS (legacy flow) ==========
+  if (importPlugins && flat.length > 0) {
+    // Use legacy discovery for non-marketplace paths
+    const discoveredPlugins: ClaudePluginCandidate[] = [];
+    const seen = new Set<string>();
+
+    for (const root of flat) {
+      walkDirs(root, (dir) => {
+        const pkgPath = join(dir, "package.json");
+        if (!existsSync(pkgPath)) return;
+        const resolvedDir = resolve(dir);
+        if (seen.has(resolvedDir)) return;
+        seen.add(resolvedDir);
+        let packageName: string | undefined;
+        try {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { name?: string };
+          packageName = pkg.name;
+        } catch {
+          packageName = undefined;
+        }
+        discoveredPlugins.push({
+          type: "plugin",
+          name: packageName || basename(dir),
+          packageName,
+          path: resolvedDir,
+          root,
+          sourceLabel: sourceLabel(root),
+        });
+      }, 4);
+    }
+
+    const sortedPlugins = discoveredPlugins.sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+    const selectedPlugins = await chooseMany(ctx, `Claude plugins/packages → ${scope} Pi settings`, sortedPlugins);
+
+    if (selectedPlugins.length > 0) {
+      const pluginPaths = selectedPlugins.map((plugin) => plugin.path);
+      if (scope === "project") {
+        settingsManager.setProjectPackages(mergePackageSources(settingsManager.getProjectSettings().packages, pluginPaths));
+      } else {
+        settingsManager.setPackages(mergePackageSources(settingsManager.getGlobalSettings().packages, pluginPaths));
+      }
+      importedPluginsCount = selectedPlugins.length;
+    }
+  }
+
+  // ========== FINAL SUMMARY ==========
+  if (importedSkillsCount === 0 && importedPluginsCount === 0 && importedMarketplaceComponents === 0) {
+    ctx.ui.notify("Claude import cancelled or nothing selected.", "info");
+    return;
+  }
+
+  await ctx.waitForIdle();
+  await ctx.reload();
+
+  const lines = [
+    `Imported Claude assets into ${scope} config:`,
+    `- Skills (flat): ${importedSkillsCount}`,
+    `- Plugins (flat paths): ${importedPluginsCount}`,
+    `- Marketplace components: ${importedMarketplaceComponents}`,
+  ];
+  if (importedSkillsCount > 0) {
+    lines.push(`- Skill paths added to Pi settings (${scope}) for availability`);
+    lines.push(`- Skill refs added to GSD preferences (${scope}) when selected`);
+  }
+  if (importedPluginsCount > 0) {
+    lines.push(`- Plugin/package paths added to Pi settings (${scope}) packages`);
+  }
+  if (importedMarketplaceComponents > 0) {
+    lines.push(`- Canonical names preserved: ${canonicalNamesPersisted.length} entries`);
+    if (canonicalNamesPersisted.length <= 10) {
+      lines.push(`  Names: ${canonicalNamesPersisted.join(', ')}`);
+    }
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}