@xelauvas/xela-cli 0.1.0

package/src/commands/plugin/ValidatePlugin.tsx

@@ -0,0 +1,98 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { useEffect } from 'react';
+import { Box, Text } from '../../ink.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { validateManifest } from '../../utils/plugins/validatePlugin.js';
+import { plural } from '../../utils/stringUtils.js';
+type Props = {
+  onComplete: (result?: string) => void;
+  path?: string;
+};
+export function ValidatePlugin(t0) {
+  const $ = _c(5);
+  const {
+    onComplete,
+    path
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== onComplete || $[1] !== path) {
+    t1 = () => {
+      const runValidation = async function runValidation() {
+        if (!path) {
+          onComplete("Usage: /plugin validate <path>\n\nValidate a plugin or marketplace manifest file or directory.\n\nExamples:\n  /plugin validate .claude-plugin/plugin.json\n  /plugin validate /path/to/plugin-directory\n  /plugin validate .\n\nWhen given a directory, automatically validates .claude-plugin/marketplace.json\nor .claude-plugin/plugin.json (prefers marketplace if both exist).\n\nOr from the command line:\n  claude plugin validate <path>");
+          return;
+        }
+        ;
+        try {
+          const result = await validateManifest(path);
+          let output = "";
+          output = output + `Validating ${result.fileType} manifest: ${result.filePath}\n\n`;
+          output;
+          if (result.errors.length > 0) {
+            output = output + `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, "error")}:\n\n`;
+            output;
+            result.errors.forEach(error_0 => {
+              output = output + `  ${figures.pointer} ${error_0.path}: ${error_0.message}\n`;
+              output;
+            });
+            output = output + "\n";
+            output;
+          }
+          if (result.warnings.length > 0) {
+            output = output + `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, "warning")}:\n\n`;
+            output;
+            result.warnings.forEach(warning => {
+              output = output + `  ${figures.pointer} ${warning.path}: ${warning.message}\n`;
+              output;
+            });
+            output = output + "\n";
+            output;
+          }
+          if (result.success) {
+            if (result.warnings.length > 0) {
+              output = output + `${figures.tick} Validation passed with warnings\n`;
+              output;
+            } else {
+              output = output + `${figures.tick} Validation passed\n`;
+              output;
+            }
+            process.exitCode = 0;
+          } else {
+            output = output + `${figures.cross} Validation failed\n`;
+            output;
+            process.exitCode = 1;
+          }
+          onComplete(output);
+        } catch (t3) {
+          const error = t3;
+          process.exitCode = 2;
+          logError(error);
+          onComplete(`${figures.cross} Unexpected error during validation: ${errorMessage(error)}`);
+        }
+      };
+      runValidation();
+    };
+    t2 = [onComplete, path];
+    $[0] = onComplete;
+    $[1] = path;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = <Box flexDirection="column"><Text>Running validation...</Text></Box>;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","Box","Text","errorMessage","logError","validateManifest","plural","Props","onComplete","result","path","ValidatePlugin","t0","$","_c","t1","t2","runValidation","output","fileType","filePath","errors","length","cross","forEach","error_0","pointer","error","message","warnings","warning","success","tick","process","exitCode","t3","Symbol","for"],"sources":["ValidatePlugin.tsx"],"sourcesContent":["import figures from 'figures'\nimport * as React from 'react'\nimport { useEffect } from 'react'\nimport { Box, Text } from '../../ink.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { validateManifest } from '../../utils/plugins/validatePlugin.js'\nimport { plural } from '../../utils/stringUtils.js'\n\ntype Props = {\n  onComplete: (result?: string) => void\n  path?: string\n}\n\nexport function ValidatePlugin({ onComplete, path }: Props): React.ReactNode {\n  useEffect(() => {\n    async function runValidation() {\n      // If no path provided, show usage\n      if (!path) {\n        onComplete(\n          'Usage: /plugin validate <path>\\n\\n' +\n            'Validate a plugin or marketplace manifest file or directory.\\n\\n' +\n            'Examples:\\n' +\n            '  /plugin validate .claude-plugin/plugin.json\\n' +\n            '  /plugin validate /path/to/plugin-directory\\n' +\n            '  /plugin validate .\\n\\n' +\n            'When given a directory, automatically validates .claude-plugin/marketplace.json\\n' +\n            'or .claude-plugin/plugin.json (prefers marketplace if both exist).\\n\\n' +\n            'Or from the command line:\\n' +\n            '  claude plugin validate <path>',\n        )\n        return\n      }\n\n      try {\n        const result = await validateManifest(path)\n\n        let output = ''\n\n        // Add header\n        output += `Validating ${result.fileType} manifest: ${result.filePath}\\n\\n`\n\n        // Show errors\n        if (result.errors.length > 0) {\n          output += `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, 'error')}:\\n\\n`\n\n          result.errors.forEach(error => {\n            output += `  ${figures.pointer} ${error.path}: ${error.message}\\n`\n          })\n\n          output += '\\n'\n        }\n\n        // Show warnings\n        if (result.warnings.length > 0) {\n          output += `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, 'warning')}:\\n\\n`\n\n          result.warnings.forEach(warning => {\n            output += `  ${figures.pointer} ${warning.path}: ${warning.message}\\n`\n          })\n\n          output += '\\n'\n        }\n\n        // Show success or failure\n        if (result.success) {\n          if (result.warnings.length > 0) {\n            output += `${figures.tick} Validation passed with warnings\\n`\n          } else {\n            output += `${figures.tick} Validation passed\\n`\n          }\n\n          // Exit with code 0 (success)\n          process.exitCode = 0\n        } else {\n          output += `${figures.cross} Validation failed\\n`\n\n          // Exit with code 1 (validation failure)\n          process.exitCode = 1\n        }\n\n        onComplete(output)\n      } catch (error) {\n        // Exit with code 2 (unexpected error)\n        process.exitCode = 2\n\n        logError(error)\n\n        onComplete(\n          `${figures.cross} Unexpected error during validation: ${errorMessage(error)}`,\n        )\n      }\n    }\n\n    void runValidation()\n  }, [onComplete, path])\n\n  return (\n    <Box flexDirection=\"column\">\n      <Text>Running validation...</Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/plugin/index.tsx

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js';
+const plugin = {
+  type: 'local-jsx',
+  name: 'plugin',
+  aliases: ['plugins', 'marketplace'],
+  description: 'Manage Claude Code plugins',
+  immediate: true,
+  load: () => import('./plugin.js')
+} satisfies Command;
+export default plugin;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDb21tYW5kIiwicGx1Z2luIiwidHlwZSIsIm5hbWUiLCJhbGlhc2VzIiwiZGVzY3JpcHRpb24iLCJpbW1lZGlhdGUiLCJsb2FkIl0sInNvdXJjZXMiOlsiaW5kZXgudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQ29tbWFuZCB9IGZyb20gJy4uLy4uL2NvbW1hbmRzLmpzJ1xuXG5jb25zdCBwbHVnaW4gPSB7XG4gIHR5cGU6ICdsb2NhbC1qc3gnLFxuICBuYW1lOiAncGx1Z2luJyxcbiAgYWxpYXNlczogWydwbHVnaW5zJywgJ21hcmtldHBsYWNlJ10sXG4gIGRlc2NyaXB0aW9uOiAnTWFuYWdlIENsYXVkZSBDb2RlIHBsdWdpbnMnLFxuICBpbW1lZGlhdGU6IHRydWUsXG4gIGxvYWQ6ICgpID0+IGltcG9ydCgnLi9wbHVnaW4uanMnKSxcbn0gc2F0aXNmaWVzIENvbW1hbmRcblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luXG4iXSwibWFwcGluZ3MiOiJBQUFBLGNBQWNBLE9BQU8sUUFBUSxtQkFBbUI7QUFFaEQsTUFBTUMsTUFBTSxHQUFHO0VBQ2JDLElBQUksRUFBRSxXQUFXO0VBQ2pCQyxJQUFJLEVBQUUsUUFBUTtFQUNkQyxPQUFPLEVBQUUsQ0FBQyxTQUFTLEVBQUUsYUFBYSxDQUFDO0VBQ25DQyxXQUFXLEVBQUUsNEJBQTRCO0VBQ3pDQyxTQUFTLEVBQUUsSUFBSTtFQUNmQyxJQUFJLEVBQUVBLENBQUEsS0FBTSxNQUFNLENBQUMsYUFBYTtBQUNsQyxDQUFDLFdBQVdQLE9BQU87QUFFbkIsZUFBZUMsTUFBTSIsImlnbm9yZUxpc3QiOltdfQ==

package/src/commands/plugin/parseArgs.ts

@@ -0,0 +1,103 @@
+// Parse plugin subcommand arguments into structured commands
+export type ParsedCommand =
+  | { type: 'menu' }
+  | { type: 'help' }
+  | { type: 'install'; marketplace?: string; plugin?: string }
+  | { type: 'manage' }
+  | { type: 'uninstall'; plugin?: string }
+  | { type: 'enable'; plugin?: string }
+  | { type: 'disable'; plugin?: string }
+  | { type: 'validate'; path?: string }
+  | {
+      type: 'marketplace'
+      action?: 'add' | 'remove' | 'update' | 'list'
+      target?: string
+    }
+
+export function parsePluginArgs(args?: string): ParsedCommand {
+  if (!args) {
+    return { type: 'menu' }
+  }
+
+  const parts = args.trim().split(/\s+/)
+  const command = parts[0]?.toLowerCase()
+
+  switch (command) {
+    case 'help':
+    case '--help':
+    case '-h':
+      return { type: 'help' }
+
+    case 'install':
+    case 'i': {
+      const target = parts[1]
+      if (!target) {
+        return { type: 'install' }
+      }
+
+      // Check if it's in format plugin@marketplace
+      if (target.includes('@')) {
+        const [plugin, marketplace] = target.split('@')
+        return { type: 'install', plugin, marketplace }
+      }
+
+      // Check if the target looks like a marketplace (URL or path)
+      const isMarketplace =
+        target.startsWith('http://') ||
+        target.startsWith('https://') ||
+        target.startsWith('file://') ||
+        target.includes('/') ||
+        target.includes('\\')
+
+      if (isMarketplace) {
+        // This is a marketplace URL/path, no plugin specified
+        return { type: 'install', marketplace: target }
+      }
+
+      // Otherwise treat it as a plugin name
+      return { type: 'install', plugin: target }
+    }
+
+    case 'manage':
+      return { type: 'manage' }
+
+    case 'uninstall':
+      return { type: 'uninstall', plugin: parts[1] }
+
+    case 'enable':
+      return { type: 'enable', plugin: parts[1] }
+
+    case 'disable':
+      return { type: 'disable', plugin: parts[1] }
+
+    case 'validate': {
+      const target = parts.slice(1).join(' ').trim()
+      return { type: 'validate', path: target || undefined }
+    }
+
+    case 'marketplace':
+    case 'market': {
+      const action = parts[1]?.toLowerCase()
+      const target = parts.slice(2).join(' ')
+
+      switch (action) {
+        case 'add':
+          return { type: 'marketplace', action: 'add', target }
+        case 'remove':
+        case 'rm':
+          return { type: 'marketplace', action: 'remove', target }
+        case 'update':
+          return { type: 'marketplace', action: 'update', target }
+        case 'list':
+          return { type: 'marketplace', action: 'list' }
+        default:
+          // No action specified, show marketplace menu
+          return { type: 'marketplace' }
+      }
+    }
+
+    default:
+      // Unknown command, show menu
+      return { type: 'menu' }
+  }
+}

package/src/commands/plugin/plugin.tsx

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { PluginSettings } from './PluginSettings.js';
+export async function call(onDone: LocalJSXCommandOnDone, _context: unknown, args?: string): Promise<React.ReactNode> {
+  return <PluginSettings onComplete={onDone} args={args} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkxvY2FsSlNYQ29tbWFuZE9uRG9uZSIsIlBsdWdpblNldHRpbmdzIiwiY2FsbCIsIm9uRG9uZSIsIl9jb250ZXh0IiwiYXJncyIsIlByb21pc2UiLCJSZWFjdE5vZGUiXSwic291cmNlcyI6WyJwbHVnaW4udHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHR5cGUgeyBMb2NhbEpTWENvbW1hbmRPbkRvbmUgfSBmcm9tICcuLi8uLi90eXBlcy9jb21tYW5kLmpzJ1xuaW1wb3J0IHsgUGx1Z2luU2V0dGluZ3MgfSBmcm9tICcuL1BsdWdpblNldHRpbmdzLmpzJ1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY2FsbChcbiAgb25Eb25lOiBMb2NhbEpTWENvbW1hbmRPbkRvbmUsXG4gIF9jb250ZXh0OiB1bmtub3duLFxuICBhcmdzPzogc3RyaW5nLFxuKTogUHJvbWlzZTxSZWFjdC5SZWFjdE5vZGU+IHtcbiAgcmV0dXJuIDxQbHVnaW5TZXR0aW5ncyBvbkNvbXBsZXRlPXtvbkRvbmV9IGFyZ3M9e2FyZ3N9IC8+XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBS0EsS0FBSyxNQUFNLE9BQU87QUFDOUIsY0FBY0MscUJBQXFCLFFBQVEsd0JBQXdCO0FBQ25FLFNBQVNDLGNBQWMsUUFBUSxxQkFBcUI7QUFFcEQsT0FBTyxlQUFlQyxJQUFJQSxDQUN4QkMsTUFBTSxFQUFFSCxxQkFBcUIsRUFDN0JJLFFBQVEsRUFBRSxPQUFPLEVBQ2pCQyxJQUFhLENBQVIsRUFBRSxNQUFNLENBQ2QsRUFBRUMsT0FBTyxDQUFDUCxLQUFLLENBQUNRLFNBQVMsQ0FBQyxDQUFDO0VBQzFCLE9BQU8sQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLENBQUNKLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDRSxJQUFJLENBQUMsR0FBRztBQUMzRCIsImlnbm9yZUxpc3QiOltdfQ==

package/src/commands/plugin/pluginDetailsHelpers.tsx

@@ -0,0 +1,117 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Shared helper functions and types for plugin details views
+ *
+ * Used by both DiscoverPlugins and BrowseMarketplace components.
+ */
+
+import * as React from 'react';
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { Box, Text } from '../../ink.js';
+import type { PluginMarketplaceEntry } from '../../utils/plugins/schemas.js';
+
+/**
+ * Represents a plugin available for installation from a marketplace
+ */
+export type InstallablePlugin = {
+  entry: PluginMarketplaceEntry;
+  marketplaceName: string;
+  pluginId: string;
+  isInstalled: boolean;
+};
+
+/**
+ * Menu option for plugin details view
+ */
+export type PluginDetailsMenuOption = {
+  label: string;
+  action: string;
+};
+
+/**
+ * Extract GitHub repo info from a plugin's source
+ */
+export function extractGitHubRepo(plugin: InstallablePlugin): string | null {
+  const isGitHub = plugin.entry.source && typeof plugin.entry.source === 'object' && 'source' in plugin.entry.source && plugin.entry.source.source === 'github';
+  if (isGitHub && typeof plugin.entry.source === 'object' && 'repo' in plugin.entry.source) {
+    return plugin.entry.source.repo;
+  }
+  return null;
+}
+
+/**
+ * Build menu options for plugin details view with scoped installation options
+ */
+export function buildPluginDetailsMenuOptions(hasHomepage: string | undefined, githubRepo: string | null): PluginDetailsMenuOption[] {
+  const options: PluginDetailsMenuOption[] = [{
+    label: 'Install for you (user scope)',
+    action: 'install-user'
+  }, {
+    label: 'Install for all collaborators on this repository (project scope)',
+    action: 'install-project'
+  }, {
+    label: 'Install for you, in this repo only (local scope)',
+    action: 'install-local'
+  }];
+  if (hasHomepage) {
+    options.push({
+      label: 'Open homepage',
+      action: 'homepage'
+    });
+  }
+  if (githubRepo) {
+    options.push({
+      label: 'View on GitHub',
+      action: 'github'
+    });
+  }
+  options.push({
+    label: 'Back to plugin list',
+    action: 'back'
+  });
+  return options;
+}
+
+/**
+ * Key hint component for plugin selection screens
+ */
+export function PluginSelectionKeyHint(t0) {
+  const $ = _c(7);
+  const {
+    hasSelection
+  } = t0;
+  let t1;
+  if ($[0] !== hasSelection) {
+    t1 = hasSelection && <ConfigurableShortcutHint action="plugin:install" context="Plugin" fallback="i" description="install" bold={true} />;
+    $[0] = hasSelection;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  let t3;
+  let t4;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <ConfigurableShortcutHint action="plugin:toggle" context="Plugin" fallback="Space" description="toggle" />;
+    t3 = <ConfigurableShortcutHint action="select:accept" context="Select" fallback="Enter" description="details" />;
+    t4 = <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="back" />;
+    $[2] = t2;
+    $[3] = t3;
+    $[4] = t4;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] !== t1) {
+    t5 = <Box marginTop={1}><Text dimColor={true} italic={true}><Byline>{t1}{t2}{t3}{t4}</Byline></Text></Box>;
+    $[5] = t1;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  return t5;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","ConfigurableShortcutHint","Byline","Box","Text","PluginMarketplaceEntry","InstallablePlugin","entry","marketplaceName","pluginId","isInstalled","PluginDetailsMenuOption","label","action","extractGitHubRepo","plugin","isGitHub","source","repo","buildPluginDetailsMenuOptions","hasHomepage","githubRepo","options","push","PluginSelectionKeyHint","t0","$","_c","hasSelection","t1","t2","t3","t4","Symbol","for","t5"],"sources":["pluginDetailsHelpers.tsx"],"sourcesContent":["/**\n * Shared helper functions and types for plugin details views\n *\n * Used by both DiscoverPlugins and BrowseMarketplace components.\n */\n\nimport * as React from 'react'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { Byline } from '../../components/design-system/Byline.js'\nimport { Box, Text } from '../../ink.js'\nimport type { PluginMarketplaceEntry } from '../../utils/plugins/schemas.js'\n\n/**\n * Represents a plugin available for installation from a marketplace\n */\nexport type InstallablePlugin = {\n  entry: PluginMarketplaceEntry\n  marketplaceName: string\n  pluginId: string\n  isInstalled: boolean\n}\n\n/**\n * Menu option for plugin details view\n */\nexport type PluginDetailsMenuOption = {\n  label: string\n  action: string\n}\n\n/**\n * Extract GitHub repo info from a plugin's source\n */\nexport function extractGitHubRepo(plugin: InstallablePlugin): string | null {\n  const isGitHub =\n    plugin.entry.source &&\n    typeof plugin.entry.source === 'object' &&\n    'source' in plugin.entry.source &&\n    plugin.entry.source.source === 'github'\n\n  if (\n    isGitHub &&\n    typeof plugin.entry.source === 'object' &&\n    'repo' in plugin.entry.source\n  ) {\n    return plugin.entry.source.repo\n  }\n\n  return null\n}\n\n/**\n * Build menu options for plugin details view with scoped installation options\n */\nexport function buildPluginDetailsMenuOptions(\n  hasHomepage: string | undefined,\n  githubRepo: string | null,\n): PluginDetailsMenuOption[] {\n  const options: PluginDetailsMenuOption[] = [\n    { label: 'Install for you (user scope)', action: 'install-user' },\n    {\n      label: 'Install for all collaborators on this repository (project scope)',\n      action: 'install-project',\n    },\n    {\n      label: 'Install for you, in this repo only (local scope)',\n      action: 'install-local',\n    },\n  ]\n  if (hasHomepage) {\n    options.push({ label: 'Open homepage', action: 'homepage' })\n  }\n  if (githubRepo) {\n    options.push({ label: 'View on GitHub', action: 'github' })\n  }\n  options.push({ label: 'Back to plugin list', action: 'back' })\n  return options\n}\n\n/**\n * Key hint component for plugin selection screens\n */\nexport function PluginSelectionKeyHint({\n  hasSelection,\n}: {\n  hasSelection: boolean\n}): React.ReactNode {\n  return (\n    <Box marginTop={1}>\n      <Text dimColor italic>\n        <Byline>\n          {hasSelection && (\n            <ConfigurableShortcutHint\n              action=\"plugin:install\"\n              context=\"Plugin\"\n              fallback=\"i\"\n              description=\"install\"\n              bold\n            />\n          )}\n          <ConfigurableShortcutHint\n            action=\"plugin:toggle\"\n            context=\"Plugin\"\n            fallback=\"Space\"\n            description=\"toggle\"\n          />\n          <ConfigurableShortcutHint\n            action=\"select:accept\"\n            context=\"Select\"\n            fallback=\"Enter\"\n            description=\"details\"\n          />\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"back\"\n          />\n        </Byline>\n      </Text>\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/plugin/usePagination.ts

@@ -0,0 +1,171 @@
+import { useCallback, useMemo, useRef } from 'react'
+
+const DEFAULT_MAX_VISIBLE = 5
+
+type UsePaginationOptions = {
+  totalItems: number
+  maxVisible?: number
+  selectedIndex?: number
+}
+
+type UsePaginationResult<T> = {
+  // For backwards compatibility with page-based terminology
+  currentPage: number
+  totalPages: number
+  startIndex: number
+  endIndex: number
+  needsPagination: boolean
+  pageSize: number
+  // Get visible slice of items
+  getVisibleItems: (items: T[]) => T[]
+  // Convert visible index to actual index
+  toActualIndex: (visibleIndex: number) => number
+  // Check if actual index is visible
+  isOnCurrentPage: (actualIndex: number) => boolean
+  // Navigation (kept for API compatibility)
+  goToPage: (page: number) => void
+  nextPage: () => void
+  prevPage: () => void
+  // Handle selection - just updates the index, scrolling is automatic
+  handleSelectionChange: (
+    newIndex: number,
+    setSelectedIndex: (index: number) => void,
+  ) => void
+  // Page navigation - returns false for continuous scrolling (not needed)
+  handlePageNavigation: (
+    direction: 'left' | 'right',
+    setSelectedIndex: (index: number) => void,
+  ) => boolean
+  // Scroll position info for UI display
+  scrollPosition: {
+    current: number
+    total: number
+    canScrollUp: boolean
+    canScrollDown: boolean
+  }
+}
+
+export function usePagination<T>({
+  totalItems,
+  maxVisible = DEFAULT_MAX_VISIBLE,
+  selectedIndex = 0,
+}: UsePaginationOptions): UsePaginationResult<T> {
+  const needsPagination = totalItems > maxVisible
+
+  // Use a ref to track the previous scroll offset for smooth scrolling
+  const scrollOffsetRef = useRef(0)
+
+  // Compute the scroll offset based on selectedIndex
+  // This ensures the selected item is always visible
+  const scrollOffset = useMemo(() => {
+    if (!needsPagination) return 0
+
+    const prevOffset = scrollOffsetRef.current
+
+    // If selected item is above the visible window, scroll up
+    if (selectedIndex < prevOffset) {
+      scrollOffsetRef.current = selectedIndex
+      return selectedIndex
+    }
+
+    // If selected item is below the visible window, scroll down
+    if (selectedIndex >= prevOffset + maxVisible) {
+      const newOffset = selectedIndex - maxVisible + 1
+      scrollOffsetRef.current = newOffset
+      return newOffset
+    }
+
+    // Selected item is within visible window, keep current offset
+    // But ensure offset is still valid
+    const maxOffset = Math.max(0, totalItems - maxVisible)
+    const clampedOffset = Math.min(prevOffset, maxOffset)
+    scrollOffsetRef.current = clampedOffset
+    return clampedOffset
+  }, [selectedIndex, maxVisible, needsPagination, totalItems])
+
+  const startIndex = scrollOffset
+  const endIndex = Math.min(scrollOffset + maxVisible, totalItems)
+
+  const getVisibleItems = useCallback(
+    (items: T[]): T[] => {
+      if (!needsPagination) return items
+      return items.slice(startIndex, endIndex)
+    },
+    [needsPagination, startIndex, endIndex],
+  )
+
+  const toActualIndex = useCallback(
+    (visibleIndex: number): number => {
+      return startIndex + visibleIndex
+    },
+    [startIndex],
+  )
+
+  const isOnCurrentPage = useCallback(
+    (actualIndex: number): boolean => {
+      return actualIndex >= startIndex && actualIndex < endIndex
+    },
+    [startIndex, endIndex],
+  )
+
+  // These are mostly no-ops for continuous scrolling but kept for API compatibility
+  const goToPage = useCallback((_page: number) => {
+    // No-op - scrolling is controlled by selectedIndex
+  }, [])
+
+  const nextPage = useCallback(() => {
+    // No-op - scrolling is controlled by selectedIndex
+  }, [])
+
+  const prevPage = useCallback(() => {
+    // No-op - scrolling is controlled by selectedIndex
+  }, [])
+
+  // Simple selection handler - just updates the index
+  // Scrolling happens automatically via the useMemo above
+  const handleSelectionChange = useCallback(
+    (newIndex: number, setSelectedIndex: (index: number) => void) => {
+      const clampedIndex = Math.max(0, Math.min(newIndex, totalItems - 1))
+      setSelectedIndex(clampedIndex)
+    },
+    [totalItems],
+  )
+
+  // Page navigation - disabled for continuous scrolling
+  const handlePageNavigation = useCallback(
+    (
+      _direction: 'left' | 'right',
+      _setSelectedIndex: (index: number) => void,
+    ): boolean => {
+      return false
+    },
+    [],
+  )
+
+  // Calculate page-like values for backwards compatibility
+  const totalPages = Math.max(1, Math.ceil(totalItems / maxVisible))
+  const currentPage = Math.floor(scrollOffset / maxVisible)
+
+  return {
+    currentPage,
+    totalPages,
+    startIndex,
+    endIndex,
+    needsPagination,
+    pageSize: maxVisible,
+    getVisibleItems,
+    toActualIndex,
+    isOnCurrentPage,
+    goToPage,
+    nextPage,
+    prevPage,
+    handleSelectionChange,
+    handlePageNavigation,
+    scrollPosition: {
+      current: selectedIndex + 1,
+      total: totalItems,
+      canScrollUp: scrollOffset > 0,
+      canScrollDown: scrollOffset + maxVisible < totalItems,
+    },
+  }
+}

package/src/commands/pr_comments/index.ts

@@ -0,0 +1,50 @@
+import { createMovedToPluginCommand } from '../createMovedToPluginCommand.js'
+
+export default createMovedToPluginCommand({
+  name: 'pr-comments',
+  description: 'Get comments from a GitHub pull request',
+  progressMessage: 'fetching PR comments',
+  pluginName: 'pr-comments',
+  pluginCommand: 'pr-comments',
+  async getPromptWhileMarketplaceIsPrivate(args) {
+    return [
+      {
+        type: 'text',
+        text: `You are an AI assistant integrated into a git-based version control system. Your task is to fetch and display comments from a GitHub pull request.
+
+Follow these steps:
+
+1. Use \`gh pr view --json number,headRepository\` to get the PR number and repository info
+2. Use \`gh api /repos/{owner}/{repo}/issues/{number}/comments\` to get PR-level comments
+3. Use \`gh api /repos/{owner}/{repo}/pulls/{number}/comments\` to get review comments. Pay particular attention to the following fields: \`body\`, \`diff_hunk\`, \`path\`, \`line\`, etc. If the comment references some code, consider fetching it using eg \`gh api /repos/{owner}/{repo}/contents/{path}?ref={branch} | jq .content -r | base64 -d\`
+4. Parse and format all comments in a readable way
+5. Return ONLY the formatted comments, with no additional text
+
+Format the comments as:
+
+## Comments
+
+[For each comment thread:]
+- @author file.ts#line:
+  \`\`\`diff
+  [diff_hunk from the API response]
+  \`\`\`
+  > quoted comment text
+
+  [any replies indented]
+
+If there are no comments, return "No comments found."
+
+Remember:
+1. Only show the actual comments, no explanatory text
+2. Include both PR-level and code review comments
+3. Preserve the threading/nesting of comment replies
+4. Show the file and line number context for code review comments
+5. Use jq to parse the JSON responses from the GitHub API
+
+${args ? 'Additional user input: ' + args : ''}
+`,
+      },
+    ]
+  },
+})

package/src/commands/privacy-settings/index.ts

@@ -0,0 +1,14 @@
+import type { Command } from '../../commands.js'
+import { isConsumerSubscriber } from '../../utils/auth.js'
+
+const privacySettings = {
+  type: 'local-jsx',
+  name: 'privacy-settings',
+  description: 'View and update your privacy settings',
+  isEnabled: () => {
+    return isConsumerSubscriber()
+  },
+  load: () => import('./privacy-settings.js'),
+} satisfies Command
+
+export default privacySettings