Plugin Types

interface BunliPlugin<TStore = {}> {
  /** Unique plugin name */
  name: string
  
  /** Optional plugin version */
  version?: string
  
  /** Plugin store schema/initial state */
  store?: TStore
  
  /** Setup hook - Called during CLI initialization */
  setup?(context: PluginContext): void | Promise<void>
  
  /** Config resolved hook - Called after all configuration is finalized */
  configResolved?(config: ResolvedConfig): void | Promise<void>
  
  /** Before command hook - Called before command execution */
  beforeCommand?(context: CommandContext<any>): void | Promise<void>
  
  /** After command hook - Called after command execution */
  afterCommand?(context: CommandContext<any> & CommandResult): void | Promise<void>
}

type PluginFactory<TOptions = unknown, TStore = {}> = 
  (options?: TOptions) => BunliPlugin<TStore>

interface MyPluginOptions {
  enabled: boolean
  threshold: number
}

interface MyPluginStore {
  count: number
}

const myPlugin: PluginFactory<MyPluginOptions, MyPluginStore> = (options) => ({
  name: 'my-plugin',
  store: { count: 0 },
  beforeCommand(context) {
    if (options.enabled) {
      context.store.count++
    }
  }
})

type PluginConfig = 
  | string                    // Path to plugin module
  | BunliPlugin              // Plugin object
  | PluginFactory            // Plugin factory function
  | [PluginFactory, unknown] // Plugin factory with options tuple

export default {
  plugins: [
    // String path
    './plugins/my-plugin.ts',
    
    // Plugin object
    { name: 'inline-plugin', setup: () => {} },
    
    // Factory without options
    myPlugin,
    
    // Factory with options
    myPlugin({ enabled: true, threshold: 10 }),
    
    // Tuple syntax
    [myPlugin, { enabled: true }]
  ]
}

type StoreOf<P> = P extends BunliPlugin<infer S> ? S : {}

const myPlugin = createPlugin<{ count: number }>({
  name: 'my-plugin',
  store: { count: 0 }
})

type MyStore = StoreOf<typeof myPlugin>
// Result: { count: number }

type MergeStores<Plugins extends readonly BunliPlugin[]> = 
  Plugins extends readonly []
    ? {}
    : Plugins extends readonly [infer First, ...infer Rest]
      ? First extends BunliPlugin
        ? Rest extends readonly BunliPlugin[]
          ? StoreOf<First> & MergeStores<Rest>
          : StoreOf<First>
        : {}
      : {}

const plugin1 = createPlugin<{ count: number }>({
  name: 'plugin1',
  store: { count: 0 }
})

const plugin2 = createPlugin<{ message: string }>({
  name: 'plugin2',
  store: { message: '' }
})

type Combined = MergeStores<[typeof plugin1, typeof plugin2]>
// Result: { count: number; message: string }

interface PluginContext {
  /** Current configuration (being built) */
  readonly config: BunliConfigInput
  
  /** Update configuration */
  updateConfig(partial: Partial<BunliConfigInput>): void
  
  /** Register a new command */
  registerCommand(command: CommandDefinition): void
  
  /** Add global middleware */
  use(middleware: Middleware): void
  
  /** Shared storage between plugins */
  readonly store: Map<string, unknown>
  
  /** Plugin logger */
  readonly logger: Logger
  
  /** System paths */
  readonly paths: PathInfo
}

interface CommandContext<TStore = {}> {
  /** Command name being executed */
  readonly command: string
  
  /** The Command object being executed */
  readonly commandDef: Command<any, TStore>
  
  /** Positional arguments */
  readonly args: string[]
  
  /** Parsed flags/options */
  readonly flags: Record<string, unknown>
  
  /** Environment information */
  readonly env: EnvironmentInfo
  
  /** Type-safe context store */
  readonly store: TStore
  
  /** Type-safe store value access */
  getStoreValue<K extends keyof TStore>(key: K): TStore[K]
  getStoreValue(key: string | number | symbol): unknown
  
  /** Type-safe store value update */
  setStoreValue<K extends keyof TStore>(key: K, value: TStore[K]): void
  setStoreValue(key: string | number | symbol, value: unknown): void
  
  /** Check if a store property exists */
  hasStoreValue<K extends keyof TStore>(key: K): boolean
  hasStoreValue(key: string | number | symbol): boolean
}

interface CommandResult {
  /** Command return value */
  result?: unknown
  
  /** Error if command failed */
  error?: unknown
  
  /** Exit code */
  exitCode?: number
}

interface PathInfo {
  /** Current working directory */
  cwd: string
  
  /** User home directory */
  home: string
  
  /** Config directory path */
  config: string
}

interface EnvironmentInfo {
  /** Running in CI environment */
  isCI: boolean
}

type Middleware = (
  context: CommandContext, 
  next: () => Promise<unknown>
) => Promise<unknown>

const timingMiddleware: Middleware = async (context, next) => {
  const start = Date.now()
  await next()
  const duration = Date.now() - start
  console.log(`Command took ${duration}ms`)
}

// In plugin setup:
setup(context) {
  context.use(timingMiddleware)
}

type CommandDefinition = Command<any>

declare module '@bunli/core' {
  interface PluginStore {
    // Add your custom store properties
    myPlugin: {
      customData: string
    }
  }
  
  interface CommandContext {
    // Add custom context methods
    myCustomMethod(): void
  }
}

// my-plugin.ts
import type {} from '@bunli/core'

declare module '@bunli/core' {
  interface PluginStore {
    auth: {
      token: string | null
      user: string | null
    }
  }
}

export const authPlugin = createPlugin<{ token: string }>(options => ({
  name: 'auth-plugin',
  store: {
    auth: {
      token: options.token,
      user: null
    }
  },
  beforeCommand(context) {
    // TypeScript knows about auth property
    if (!context.store.auth.token) {
      throw new Error('Not authenticated')
    }
  }
}))

type InferPluginOptions<T> = T extends PluginFactory<infer O, any> ? O : never

// Example
const myPlugin = createPlugin((options: { enabled: boolean }) => ({
  name: 'my-plugin'
}))

type Options = InferPluginOptions<typeof myPlugin>
// Result: { enabled: boolean }

type InferPluginStore<T> = 
  T extends BunliPlugin<infer S> ? S 
  : T extends PluginFactory<any, infer S> ? S 
  : {}

// Example
const myPlugin = createPlugin<{}, { count: number }>(options => ({
  name: 'my-plugin',
  store: { count: 0 }
}))

type Store = InferPluginStore<ReturnType<typeof myPlugin>>
// Result: { count: number }