@gustavobrunodev/ai-tools 1.0.1 → 1.1.0

package/src/components/__tests__/SkillDetailPanel.test.tsx

@@ -0,0 +1,273 @@
+/** @jest-environment jsdom */
+import { render } from '@testing-library/react'
+import React from 'react'
+
+jest.mock('../../services/category-colors', () => ({
+  getColorForCategory: (id: string) => (id === 'web' ? '#3b82f6' : '#64748b'),
+}))
+
+jest.mock('../../services/markdown-parser', () => ({
+  parseMarkdown: (raw: string) => {
+    const lines = raw
+      .replace(/^---[\s\S]*?---\n*/m, '')
+      .split('\n')
+      .filter(Boolean)
+    return lines.map((line: string) => {
+      const headingMatch = line.match(/^(#{1,3})\s+(.+)$/)
+      if (headingMatch) return { type: 'heading', level: headingMatch[1].length, text: headingMatch[2] }
+      const listMatch = line.match(/^[-*]\s+(.+)$/)
+      if (listMatch) return { type: 'list-item', text: listMatch[1], indent: 0 }
+      return { type: 'paragraph', text: line }
+    })
+  },
+}))
+
+jest.mock('chalk', () => {
+  const passthrough = (text: string) => text
+  const chainableFn = Object.assign(passthrough, {
+    bold: passthrough,
+    dim: passthrough,
+    underline: passthrough,
+    italic: passthrough,
+  })
+
+  return {
+    __esModule: true,
+    default: {
+      hex: () => chainableFn,
+      bold: passthrough,
+      dim: passthrough,
+      underline: passthrough,
+      italic: passthrough,
+    },
+  }
+})
+
+jest.mock('../../theme', () => ({
+  colors: {
+    primary: '#3b82f6',
+    primaryLight: '#60a5fa',
+    accent: '#06b6d4',
+    text: '#f8fafc',
+    textDim: '#94a3b8',
+    textMuted: '#64748b',
+    border: '#334155',
+    bg: '#0f172a',
+    bgLight: '#1e293b',
+    success: '#22c55e',
+    error: '#ef4444',
+  },
+  symbols: {
+    sparkle: '✦',
+    diamond: '◆',
+    arrow: '›',
+    dot: '·',
+    bullet: '▸',
+    cross: '✗',
+    info: 'ℹ',
+    arrowDown: '↓',
+    arrowUp: '↑',
+    bar: '│',
+  },
+}))
+
+jest.mock('ink', () => ({
+  Box: ({ children, ...props }: React.PropsWithChildren<Record<string, unknown>>) => {
+    const {
+      flexDirection,
+      width,
+      height,
+      marginTop,
+      marginBottom,
+      paddingX,
+      paddingY,
+      paddingLeft,
+      borderStyle,
+      borderColor,
+      flexGrow,
+      flexShrink,
+      justifyContent,
+      alignItems,
+      gap,
+      overflow,
+      overflowX,
+      overflowY,
+      minHeight,
+      ...validProps
+    } = props
+    void flexDirection
+    void width
+    void height
+    void marginTop
+    void marginBottom
+    void paddingX
+    void paddingY
+    void paddingLeft
+    void borderStyle
+    void borderColor
+    void flexGrow
+    void flexShrink
+    void justifyContent
+    void alignItems
+    void gap
+    void overflow
+    void overflowX
+    void overflowY
+    void minHeight
+    return (
+      <div data-testid="box" {...validProps}>
+        {children}
+      </div>
+    )
+  },
+  Text: ({ children, ...props }: React.PropsWithChildren<Record<string, unknown>>) => {
+    const { bold, underline, dimColor, wrap, backgroundColor, ...validProps } = props
+    void bold
+    void underline
+    void dimColor
+    void wrap
+    void backgroundColor
+    return (
+      <span data-testid="text" {...validProps}>
+        {children}
+      </span>
+    )
+  },
+  useStdout: () => ({ stdout: { rows: 40, columns: 140 } }),
+  useInput: jest.fn(),
+}))
+
+jest.mock('ink-spinner', () => ({
+  __esModule: true,
+  default: () => <span data-testid="spinner">⠋</span>,
+}))
+
+const mockUseSkillContent = jest.fn()
+jest.mock('../../hooks/useSkillContent', () => ({
+  useSkillContent: (...args: unknown[]) => mockUseSkillContent(...args),
+}))
+
+import type { SkillInfo } from '../../types'
+import { SkillDetailPanel } from '../SkillDetailPanel'
+
+const mockSkill: SkillInfo = {
+  name: 'api-designer',
+  description: 'Design RESTful APIs with best practices',
+  category: 'web',
+  path: '/path/to/skill',
+}
+
+describe('SkillDetailPanel', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('renders nothing when skill is null', () => {
+    mockUseSkillContent.mockReturnValue({ metadata: null, content: null, loading: false, error: null })
+    const { container } = render(<SkillDetailPanel skill={null} onClose={jest.fn()} />)
+    expect(container.innerHTML).toBe('')
+  })
+
+  it('shows loading state', () => {
+    mockUseSkillContent.mockReturnValue({ metadata: null, content: null, loading: true, error: null })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('Loading')
+  })
+
+  it('shows error state', () => {
+    mockUseSkillContent.mockReturnValue({ metadata: null, content: null, loading: false, error: 'Network error' })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('Network error')
+  })
+
+  it('displays skill metadata header', () => {
+    mockUseSkillContent.mockReturnValue({
+      metadata: { name: 'api-designer', author: 'techleads', files: ['SKILL.md', 'README.md'] },
+      content: '# API Designer\n\nDesign APIs.',
+      loading: false,
+      error: null,
+    })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('api-designer')
+    expect(container.textContent).toContain('web')
+    expect(container.textContent).toContain('@techleads')
+    expect(container.textContent).toContain('2 files')
+  })
+
+  it('displays singular file count for 1 file', () => {
+    mockUseSkillContent.mockReturnValue({
+      metadata: { name: 'api-designer', files: ['SKILL.md'] },
+      content: '# Title',
+      loading: false,
+      error: null,
+    })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('1 file')
+    expect(container.textContent).not.toContain('1 files')
+  })
+
+  it('renders parsed markdown content as formatted text', () => {
+    mockUseSkillContent.mockReturnValue({
+      metadata: { name: 'api-designer', files: ['SKILL.md'] },
+      content: '# My Skill\n\nA paragraph here.\n\n- Item one\n- Item two',
+      loading: false,
+      error: null,
+    })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    // Content is pre-formatted with chalk into a single string
+    expect(container.textContent).toContain('My Skill')
+    expect(container.textContent).toContain('A paragraph here.')
+    expect(container.textContent).toContain('Item one')
+  })
+
+  it('shows panel title bar with expand and close hints', () => {
+    mockUseSkillContent.mockReturnValue({ metadata: null, content: null, loading: true, error: null })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('Skill Details')
+    expect(container.textContent).toContain('f')
+    expect(container.textContent).toContain('Esc')
+  })
+
+  it('hides author when not available', () => {
+    mockUseSkillContent.mockReturnValue({
+      metadata: { name: 'api-designer', files: ['SKILL.md'] },
+      content: '# Title',
+      loading: false,
+      error: null,
+    })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).not.toContain('@')
+  })
+
+  it('displays skill description from props', () => {
+    mockUseSkillContent.mockReturnValue({
+      metadata: { name: 'api-designer', files: [] },
+      content: '# Title',
+      loading: false,
+      error: null,
+    })
+    const { container } = render(<SkillDetailPanel skill={mockSkill} onClose={jest.fn()} />)
+    expect(container.textContent).toContain('Design RESTful APIs with best practices')
+  })
+
+  it('always shows name, category, and description when metadata loads', () => {
+    const skills: SkillInfo[] = [
+      { name: 'skill-a', description: 'Desc A', category: 'web', path: '' },
+      { name: 'skill-b', description: 'Desc B', category: 'devops', path: '' },
+      { name: 'skill-c', description: 'Desc C', category: 'ai', path: '' },
+    ]
+    for (const skill of skills) {
+      mockUseSkillContent.mockReturnValue({
+        metadata: { name: skill.name, files: ['SKILL.md'], author: 'author' },
+        content: '# Content',
+        loading: false,
+        error: null,
+      })
+      const { container, unmount } = render(<SkillDetailPanel skill={skill} onClose={jest.fn()} />)
+      expect(container.textContent).toContain(skill.name)
+      expect(container.textContent).toContain(skill.category)
+      expect(container.textContent).toContain(skill.description)
+      unmount()
+    }
+  })
+})

package/src/components/index.ts

@@ -0,0 +1,12 @@
+export * from './AnimatedTransition'
+export * from './CategoryHeader'
+export * from './ConfirmPrompt'
+export * from './FooterBar'
+export * from './Header'
+export * from './KeyboardShortcutsOverlay'
+export * from './MultiSelectPrompt'
+export * from './SearchInput'
+export * from './SelectPrompt'
+export * from './SkillCard'
+export * from './SkillDetailPanel'
+export * from './StatusBadge'

package/src/hooks/__tests__/useConfig.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @jest-environment jsdom
+ */
+import { jest } from '@jest/globals'
+import { act, renderHook, waitFor } from '@testing-library/react'
+
+const mockMkdir = jest.fn<() => Promise<void>>()
+const mockReadFile = jest.fn<(path: string, encoding: string) => Promise<string>>()
+const mockWriteFile = jest.fn<(path: string, data: string, encoding: string) => Promise<void>>()
+const mockHomedir = jest.fn<() => string>()
+const mockRename = jest.fn<(oldPath: string, newPath: string) => Promise<void>>()
+const mockRm = jest.fn<(path: string, options?: { force?: boolean }) => Promise<void>>()
+
+jest.unstable_mockModule('node:fs/promises', () => ({
+  mkdir: mockMkdir,
+  readFile: mockReadFile,
+  writeFile: mockWriteFile,
+  rename: mockRename,
+  rm: mockRm,
+}))
+
+jest.unstable_mockModule('node:os', () => ({ homedir: mockHomedir }))
+
+const { useConfig } = await import('../useConfig')
+
+describe('useConfig hook', () => {
+  const mockHome = '/home/testuser'
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockHomedir.mockReturnValue(mockHome)
+  })
+
+  describe('initial load', () => {
+    it('should load config on mount', async () => {
+      const config = { firstLaunchComplete: true, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      const { result } = renderHook(() => useConfig())
+      expect(result.current.loading).toBe(true)
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.config).toEqual(config)
+      expect(result.current.error).toBeNull()
+      expect(result.current.isFirstLaunch).toBe(false)
+      expect(result.current.hasShortcutsBeenDismissed).toBe(false)
+    })
+
+    it('should handle first launch state', async () => {
+      const config = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.isFirstLaunch).toBe(true)
+      expect(result.current.hasShortcutsBeenDismissed).toBe(false)
+    })
+
+    it('should handle shortcuts dismissed state', async () => {
+      const config = { firstLaunchComplete: true, shortcutsOverlayDismissed: true, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.isFirstLaunch).toBe(false)
+      expect(result.current.hasShortcutsBeenDismissed).toBe(true)
+    })
+
+    it('should handle load errors', async () => {
+      mockReadFile.mockRejectedValue(new Error('Permission denied'))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.config).toEqual({
+        firstLaunchComplete: false,
+        shortcutsOverlayDismissed: false,
+        version: '1.0.0',
+      })
+    })
+
+    it('should use default config when file does not exist', async () => {
+      mockReadFile.mockRejectedValue(new Error('ENOENT: no such file'))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.config).toEqual({
+        firstLaunchComplete: false,
+        shortcutsOverlayDismissed: false,
+        version: '1.0.0',
+      })
+      expect(result.current.isFirstLaunch).toBe(true)
+    })
+  })
+
+  describe('markFirstLaunchComplete', () => {
+    it('should update first launch state', async () => {
+      const initialConfig = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      const updatedConfig = { ...initialConfig, firstLaunchComplete: true }
+      mockReadFile
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(updatedConfig))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockResolvedValue(undefined)
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.isFirstLaunch).toBe(true)
+      await act(async () => {
+        await result.current.markFirstLaunchComplete()
+      })
+      await waitFor(() => {
+        expect(result.current.isFirstLaunch).toBe(false)
+      })
+      expect(result.current.config?.firstLaunchComplete).toBe(true)
+    })
+
+    it('should handle errors when marking first launch complete', async () => {
+      const config = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockRejectedValue(new Error('Write failed'))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      await act(async () => {
+        await expect(result.current.markFirstLaunchComplete()).rejects.toThrow('Write failed')
+      })
+      expect(result.current.error).toBe('Write failed')
+    })
+  })
+
+  describe('markShortcutsDismissed', () => {
+    it('should update shortcuts dismissed state', async () => {
+      const initialConfig = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      const updatedConfig = { ...initialConfig, shortcutsOverlayDismissed: true }
+      mockReadFile
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(updatedConfig))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockResolvedValue(undefined)
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      expect(result.current.hasShortcutsBeenDismissed).toBe(false)
+      await act(async () => {
+        await result.current.markShortcutsDismissed()
+      })
+      await waitFor(() => {
+        expect(result.current.hasShortcutsBeenDismissed).toBe(true)
+      })
+      expect(result.current.config?.shortcutsOverlayDismissed).toBe(true)
+    })
+
+    it('should handle errors when marking shortcuts dismissed', async () => {
+      const config = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockRejectedValue(new Error('Write failed'))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      await act(async () => {
+        await expect(result.current.markShortcutsDismissed()).rejects.toThrow('Write failed')
+      })
+      expect(result.current.error).toBe('Write failed')
+    })
+  })
+
+  describe('updateConfig', () => {
+    it('should update config with partial updates', async () => {
+      const initialConfig = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      const updatedConfig = { ...initialConfig, firstLaunchComplete: true, shortcutsOverlayDismissed: true }
+      mockReadFile
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(initialConfig))
+        .mockResolvedValueOnce(JSON.stringify(updatedConfig))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockResolvedValue(undefined)
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      await act(async () => {
+        await result.current.updateConfig({ firstLaunchComplete: true, shortcutsOverlayDismissed: true })
+      })
+      await waitFor(() => {
+        expect(result.current.config).toEqual(updatedConfig)
+      })
+      expect(result.current.isFirstLaunch).toBe(false)
+      expect(result.current.hasShortcutsBeenDismissed).toBe(true)
+    })
+
+    it('should handle errors when updating config', async () => {
+      const config = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockResolvedValue(JSON.stringify(config))
+      mockMkdir.mockResolvedValue(undefined)
+      mockWriteFile.mockRejectedValue(new Error('Write failed'))
+      const { result } = renderHook(() => useConfig())
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false)
+      })
+      await act(async () => {
+        await expect(result.current.updateConfig({ firstLaunchComplete: true })).rejects.toThrow('Write failed')
+      })
+      expect(result.current.error).toBe('Write failed')
+    })
+  })
+
+  describe('cleanup', () => {
+    it('should not update state after unmount', async () => {
+      const config = { firstLaunchComplete: false, shortcutsOverlayDismissed: false, version: '1.0.0' }
+      mockReadFile.mockImplementation(
+        () =>
+          new Promise((resolve) => {
+            setTimeout(() => resolve(JSON.stringify(config)), 100)
+          }),
+      )
+      const { result, unmount } = renderHook(() => useConfig())
+      expect(result.current.loading).toBe(true)
+      unmount()
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      expect(result.current.loading).toBe(true)
+      expect(result.current.config).toBeNull()
+    })
+  })
+})

package/src/hooks/index.ts

@@ -0,0 +1,9 @@
+export * from './useAgents'
+export * from './useConfig'
+export * from './useFilter'
+export * from './useInstaller'
+export * from './useKonamiCode'
+export * from './useRemover'
+export * from './useSkillContent'
+export * from './useSkills'
+export * from './useWizardStep'

package/src/hooks/useAgents.ts

@@ -0,0 +1,28 @@
+import { useEffect, useMemo, useState } from 'react'
+
+import { detectInstalledAgents, getAllAgentTypes } from '../services/agents'
+import type { AgentType } from '../types'
+
+export function useAgents() {
+  const [selectedAgents, setSelectedAgents] = useState<AgentType[]>([])
+  const [installedAgents, setInstalledAgents] = useState<AgentType[]>([])
+  const [loading, setLoading] = useState(true)
+  const allAgents = useMemo(() => getAllAgentTypes(), [])
+
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      const detected = detectInstalledAgents()
+      setInstalledAgents(detected)
+      setSelectedAgents(detected)
+      setLoading(false)
+    }, 800)
+
+    return () => clearTimeout(timer)
+  }, [])
+
+  const toggleAgent = (agent: AgentType) => {
+    setSelectedAgents((prev) => (prev.includes(agent) ? prev.filter((a) => a !== agent) : [...prev, agent]))
+  }
+
+  return { allAgents, installedAgents, selectedAgents, setSelectedAgents, toggleAgent, loading }
+}

package/src/hooks/useConfig.ts

@@ -0,0 +1,114 @@
+import { useEffect, useState } from 'react'
+
+import type { UserConfig } from '../services/config'
+import {
+  hasShortcutsBeenDismissed,
+  isFirstLaunch,
+  loadConfig,
+  markFirstLaunchComplete,
+  markShortcutsDismissed,
+  saveConfig,
+} from '../services/config'
+
+interface UseConfigReturn {
+  config: UserConfig | null
+  loading: boolean
+  error: string | null
+  isFirstLaunch: boolean
+  hasShortcutsBeenDismissed: boolean
+  markFirstLaunchComplete: () => Promise<void>
+  markShortcutsDismissed: () => Promise<void>
+  updateConfig: (updates: Partial<UserConfig>) => Promise<void>
+}
+
+export function useConfig(): UseConfigReturn {
+  const [config, setConfig] = useState<UserConfig | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [isFirstLaunchState, setIsFirstLaunchState] = useState(false)
+  const [hasShortcutsDismissedState, setHasShortcutsDismissedState] = useState(false)
+
+  useEffect(() => {
+    let mounted = true
+
+    const load = async () => {
+      try {
+        const [configData, firstLaunch, shortcutsDismissed] = await Promise.all([
+          loadConfig(),
+          isFirstLaunch(),
+          hasShortcutsBeenDismissed(),
+        ])
+
+        if (mounted) {
+          setConfig(configData)
+          setIsFirstLaunchState(firstLaunch)
+          setHasShortcutsDismissedState(shortcutsDismissed)
+        }
+      } catch (err: unknown) {
+        if (mounted) setError(err instanceof Error ? err.message : String(err))
+      } finally {
+        if (mounted) setLoading(false)
+      }
+    }
+
+    load()
+
+    return () => {
+      mounted = false
+    }
+  }, [])
+
+  const handleMarkFirstLaunchComplete = async () => {
+    try {
+      await markFirstLaunchComplete()
+      setIsFirstLaunchState(false)
+      const updatedConfig = await loadConfig()
+      setConfig(updatedConfig)
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+      throw err
+    }
+  }
+
+  const handleMarkShortcutsDismissed = async () => {
+    try {
+      await markShortcutsDismissed()
+      setHasShortcutsDismissedState(true)
+      const updatedConfig = await loadConfig()
+      setConfig(updatedConfig)
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+      throw err
+    }
+  }
+
+  const handleUpdateConfig = async (updates: Partial<UserConfig>) => {
+    try {
+      await saveConfig(updates)
+      const updatedConfig = await loadConfig()
+      setConfig(updatedConfig)
+
+      if ('firstLaunchComplete' in updates) {
+        setIsFirstLaunchState(!updates.firstLaunchComplete)
+      }
+
+      if ('shortcutsOverlayDismissed' in updates) {
+        setHasShortcutsDismissedState(Boolean(updates.shortcutsOverlayDismissed))
+      }
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : String(err))
+      throw err
+    }
+  }
+
+  return {
+    config,
+    loading,
+    error,
+    isFirstLaunch: isFirstLaunchState,
+    hasShortcutsBeenDismissed: hasShortcutsDismissedState,
+    markFirstLaunchComplete: handleMarkFirstLaunchComplete,
+    markShortcutsDismissed: handleMarkShortcutsDismissed,
+    updateConfig: handleUpdateConfig,
+  }
+}