asdf

Squash the current repository state back into one baseline commit while
preserving the README reframing and repository contents.

Constraint: User explicitly requested a single squashed commit with subject "asdf"
Confidence: high
Scope-risk: broad
Reversibility: clean
Directive: This commit intentionally rewrites published history; coordinate before future force-pushes
Tested: git status clean; local history rewritten to one commit; force-pushed main to origin and instructkr
Not-tested: Fresh clone verification after push

src/commands/plugin/PluginTrustWarning.tsx

@@ -0,0 +1,32 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import { getPluginTrustMessage } from '../../utils/plugins/marketplaceHelpers.js';
+export function PluginTrustWarning() {
+  const $ = _c(3);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = getPluginTrustMessage();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const customMessage = t0;
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = <Text color="claude">{figures.warning} </Text>;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = <Box marginBottom={1}>{t1}<Text dimColor={true} italic={true}>Make sure you trust a plugin before installing, updating, or using it. Anthropic does not control what MCP servers, files, or other software are included in plugins and cannot verify that they will work as intended or that they won't change. See each plugin's homepage for more information.{customMessage ? ` ${customMessage}` : ""}</Text></Box>;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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==

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' }
+  }
+}

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==

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,
+    },
+  }
+}