@gustavobrunodev/ai-tools 1.0.1 → 1.1.0

package/jest.config.ts

@@ -0,0 +1,26 @@
+import type { Config } from 'jest'
+
+const config: Config = {
+  displayName: 'cli',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'],
+  transform: {
+    '^.+\\.[tj]sx?$': [
+      'ts-jest',
+      { 
+        useESM: true, 
+        tsconfig: '<rootDir>/tsconfig.spec.json', 
+        diagnostics: { 
+          ignoreCodes: [151002],
+          warnOnly: true
+        } 
+      },
+    ],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/packages/cli',
+  moduleNameMapper: { '^@gustavobrunodev/core$': '<rootDir>/../../libs/core/src/index.ts' },
+}
+
+export default config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gustavobrunodev/ai-tools",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "CLI to install and manage AI tools (skills, MCPs, agents) for AI coding agents",
   "author": "gustavobrunodev",
   "license": "MIT",

package/project.json

@@ -0,0 +1,74 @@
+{
+  "name": "@gustavobrunodev/ai-tools",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/cli/src",
+  "projectType": "library",
+  "tags": ["scope:cli"],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "inputs": ["production", "^production"],
+      "options": {
+        "platform": "node",
+        "outputPath": "packages/cli/dist",
+        "format": ["esm"],
+        "bundle": true,
+        "main": "packages/cli/src/index.ts",
+        "tsConfig": "packages/cli/tsconfig.json",
+        "assets": [
+          {
+            "glob": "README.md",
+            "input": ".",
+            "output": "."
+          },
+          {
+            "glob": "LICENSE",
+            "input": ".",
+            "output": "."
+          },
+          {
+            "glob": "package.json",
+            "input": ".",
+            "output": "."
+          },
+          {
+            "glob": "**/*.mp3",
+            "input": "packages/cli/src/assets",
+            "output": "assets"
+          }
+        ],
+        "esbuildOptions": {
+          "sourcemap": true,
+          "outExtension": {
+            ".js": ".js"
+          },
+          "banner": {
+            "js": "#!/usr/bin/env node"
+          },
+          "platform": "node",
+          "jsx": "automatic",
+          "loader": {
+            ".tsx": "tsx"
+          }
+        }
+      },
+      "configurations": {
+        "development": {
+          "minify": false
+        },
+        "production": {
+          "minify": true
+        }
+      }
+    },
+    "post-build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "chmod +x packages/cli/dist/index.js"
+      },
+      "dependsOn": ["build"]
+    }
+  }
+}

package/src/app.tsx

@@ -0,0 +1,56 @@
+import { Box, useApp } from 'ink'
+import { useEffect, useState } from 'react'
+
+import { useKonamiCode } from './hooks'
+import { ArcadeMenu, CreditsView, InstallWizard, ListView, RemoveWizard, UpdateView } from './views'
+
+interface AppProps {
+  command?: string
+  args?: string[]
+}
+
+export const App = ({ command = 'install' }: AppProps) => {
+  const { exit } = useApp()
+  const [arcade, setArcade] = useState(command === 'arcade')
+  const { activated, reset } = useKonamiCode()
+
+  useEffect(() => {
+    if (activated && !arcade) {
+      setArcade(true)
+      reset()
+    }
+  }, [activated, arcade, reset])
+
+  if (command === 'credits') {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <CreditsView onExit={exit} />
+      </Box>
+    )
+  }
+
+  if (arcade) {
+    return (
+      <Box flexDirection="column" padding={1}>
+        <ArcadeMenu
+          onExit={() => {
+            if (command === 'arcade') {
+              exit()
+            } else {
+              setArcade(false)
+            }
+          }}
+        />
+      </Box>
+    )
+  }
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      {command === 'list' && <ListView onExit={exit} />}
+      {command === 'remove' && <RemoveWizard onExit={exit} />}
+      {command === 'update' && <UpdateView onExit={exit} />}
+      {(command === 'install' || !command) && <InstallWizard onExit={exit} />}
+    </Box>
+  )
+}

package/src/atoms/deprecatedSkills.ts

@@ -0,0 +1,11 @@
+import { atom } from 'jotai'
+import { unwrap } from 'jotai/utils'
+
+import { getDeprecatedMap } from '../services/registry'
+import type { DeprecatedEntry } from '../types'
+
+const deprecatedSkillsAsyncAtom = atom(async (): Promise<Map<string, DeprecatedEntry>> => {
+  return getDeprecatedMap()
+})
+
+export const deprecatedSkillsAtom = unwrap(deprecatedSkillsAsyncAtom, (prev) => prev ?? new Map())

package/src/atoms/environmentCheck.ts

@@ -0,0 +1,51 @@
+import { atom } from 'jotai'
+import { unwrap } from 'jotai/utils'
+
+import { isGloballyInstalled } from '../services/global-path'
+import { getCachedUpdate, setCachedUpdate } from '../services/update-cache'
+import { checkForUpdates, getCurrentVersion } from '../services/update-check'
+import { UPDATE_CHECK_TIMEOUT_MS } from '../utils/constants'
+
+export interface EnvironmentCheckState {
+  updateAvailable: string | null
+  currentVersion: string
+  isGlobal: boolean
+  isLoading?: boolean
+}
+
+async function resolveUpdateAvailable(currentVersion: string): Promise<string | null> {
+  const cached = await getCachedUpdate()
+  const cachedUpdate = cached && cached.latestVersion !== currentVersion ? cached.latestVersion : null
+
+  try {
+    const update = await Promise.race([
+      checkForUpdates(currentVersion),
+      new Promise<string | null>((_, reject) =>
+        setTimeout(() => reject(new Error('timeout')), UPDATE_CHECK_TIMEOUT_MS),
+      ),
+    ])
+
+    setCachedUpdate(update ?? currentVersion).catch(() => {})
+    return update
+  } catch {
+    return cachedUpdate
+  }
+}
+
+const runCheck = async (): Promise<EnvironmentCheckState> => {
+  const currentVersion = getCurrentVersion()
+
+  const [updateAvailable, isGlobal] = await Promise.all([
+    resolveUpdateAvailable(currentVersion).catch(() => null),
+    Promise.resolve(isGloballyInstalled()).catch(() => false),
+  ])
+
+  return { updateAvailable, currentVersion, isGlobal: isGlobal as boolean, isLoading: false }
+}
+
+const environmentCheckAsyncAtom = atom<Promise<EnvironmentCheckState>>(runCheck())
+
+export const environmentCheckAtom = unwrap(
+  environmentCheckAsyncAtom,
+  (prev) => prev ?? { updateAvailable: null, currentVersion: getCurrentVersion(), isGlobal: false, isLoading: true },
+)

package/src/atoms/installedSkills.ts

@@ -0,0 +1,36 @@
+import { atom } from 'jotai'
+import { unwrap } from 'jotai/utils'
+
+import { detectInstalledAgents } from '../services/agents'
+import { listInstalledSkills } from '../services/installer'
+import type { AgentType } from '../types'
+
+export type InstallationMap = Record<string, AgentType[]>
+
+const fetchInstalledSkills = async (): Promise<InstallationMap> => {
+  const agents = detectInstalledAgents()
+  const status: InstallationMap = {}
+
+  for (const agent of agents) {
+    const [local, global] = await Promise.all([
+      listInstalledSkills(agent, false).catch(() => []),
+      listInstalledSkills(agent, true).catch(() => []),
+    ])
+
+    for (const skill of new Set([...local, ...global])) {
+      if (!status[skill]) status[skill] = []
+      if (!status[skill].includes(agent)) status[skill].push(agent)
+    }
+  }
+
+  return status
+}
+
+export const installedSkillsRefreshAtom = atom(0)
+
+const installedSkillsAsyncAtom = atom(async (get) => {
+  get(installedSkillsRefreshAtom)
+  return fetchInstalledSkills()
+})
+
+export const installedSkillsAtom = unwrap(installedSkillsAsyncAtom, (prev) => prev ?? {})

package/src/atoms/wizard.ts

@@ -0,0 +1,6 @@
+import { atom } from 'jotai'
+
+import type { AgentType, SkillInfo } from '../types'
+
+export const selectedAgentsAtom = atom<AgentType[]>([])
+export const selectedSkillsAtom = atom<SkillInfo[]>([])

package/src/cli/audit.ts

@@ -0,0 +1,21 @@
+import { render } from 'ink'
+import React from 'react'
+
+import { AuditLogViewer } from '../components/AuditLogViewer'
+import { getAuditLogPath, readAuditLog } from '../services/audit-log'
+
+interface AuditOptions {
+  limit?: string
+  path?: boolean
+}
+
+export async function runCliAudit(options: AuditOptions) {
+  if (options.path) {
+    console.log(getAuditLogPath())
+    return
+  }
+
+  const limit = options.limit ? parseInt(options.limit, 10) : 10
+  const entries = await readAuditLog(limit)
+  render(React.createElement(AuditLogViewer, { entries, limit }))
+}

package/src/cli/cache.ts

@@ -0,0 +1,28 @@
+import chalk from 'chalk'
+
+import { clearCache, clearRegistryCache, getCacheDir } from '../services/registry'
+
+interface CacheCliOptions {
+  clear?: boolean
+  clearRegistry?: boolean
+  path?: boolean
+}
+
+export function runCliCache(options: CacheCliOptions): void {
+  if (options.clear) {
+    clearCache()
+    console.log(chalk.green('✅ Cache cleared'))
+  } else if (options.clearRegistry) {
+    clearRegistryCache()
+    console.log(chalk.green('✅ Registry cache cleared'))
+  } else if (options.path) {
+    console.log(getCacheDir())
+  } else {
+    console.log(chalk.bold('Cache management:'))
+    console.log(`  ${chalk.blue('--clear')}           Clear all cached skills and registry`)
+    console.log(`  ${chalk.blue('--clear-registry')}  Clear only the registry cache`)
+    console.log(`  ${chalk.blue('--path')}            Show cache directory path`)
+    console.log()
+    console.log(chalk.dim(`Cache location: ${getCacheDir()}`))
+  }
+}

package/src/cli/install.ts

@@ -0,0 +1,93 @@
+import chalk from 'chalk'
+
+import { installSkills } from '../services/installer'
+import { ensureSkillDownloaded, forceDownloadSkill, getRemoteSkills } from '../services/registry'
+import type { AgentType, InstallOptions, SkillInfo } from '../types'
+
+interface InstallCliOptions {
+  skill?: string[]
+  agent?: string[]
+  global?: boolean
+  symlink?: boolean
+  force?: boolean
+}
+
+async function downloadSkills(skillNames: string[], forceDownload: boolean): Promise<SkillInfo[]> {
+  const allSkills = await getRemoteSkills()
+  const selectedSkills: SkillInfo[] = []
+
+  for (const skillName of skillNames) {
+    const skill = allSkills.find((s) => s.name === skillName)
+    if (!skill) {
+      console.error(chalk.red(`❌ Skill "${skillName}" not found`))
+      continue
+    }
+
+    const path = forceDownload ? await forceDownloadSkill(skillName) : await ensureSkillDownloaded(skillName)
+    if (path) {
+      selectedSkills.push({ ...skill, path })
+    } else {
+      console.error(chalk.red(`❌ Failed to download skill "${skillName}"`))
+    }
+  }
+
+  return selectedSkills
+}
+
+function showInstallResults(results: Awaited<ReturnType<typeof installSkills>>): void {
+  const successful = results.filter((r) => r.success)
+  const failed = results.filter((r) => !r.success)
+
+  if (successful.length > 0) {
+    console.log(chalk.green(`\n✅ Successfully installed ${successful.length} skill(s):`))
+    successful.forEach((r) => {
+      console.log(chalk.dim(`  • ${r.skill} → ${r.agent} (${r.method})`))
+    })
+  }
+
+  if (failed.length > 0) {
+    console.log(chalk.red(`\n❌ Failed to install ${failed.length} skill(s):`))
+    failed.forEach((r) => {
+      console.log(chalk.dim(`  • ${r.skill} → ${r.agent}: ${r.error}`))
+    })
+  }
+}
+
+export async function runCliInstall(options: InstallCliOptions): Promise<void> {
+  if (!options.skill || options.skill.length === 0) {
+    console.error(chalk.red('❌ --skill is required in CLI mode'))
+    console.error(
+      chalk.dim('Usage: ai-tools install --skill <name1> [name2...] [--agent <agents...>] [--global] [--symlink]'),
+    )
+    process.exit(1)
+  }
+
+  const skillNames = Array.isArray(options.skill) ? options.skill : [options.skill]
+
+  console.log(chalk.blue(`⏳ Loading ${skillNames.length} skill(s) from catalog...`))
+  const skills = await downloadSkills(skillNames, options.force || false)
+
+  if (skills.length === 0) {
+    console.error(chalk.red('❌ No skills were successfully downloaded'))
+    process.exit(1)
+  }
+
+  const agents = (options.agent || ['github-copilot', 'claude-code']) as AgentType[]
+  const method = options.symlink ? 'symlink' : 'copy'
+
+  console.log(chalk.blue(`⏳ Installing ${skills.length} skill(s) to ${agents.length} agent(s)...`))
+
+  const installOptions: InstallOptions = {
+    agents,
+    skills: skills.map((s) => s.name),
+    method,
+    global: options.global || false,
+  }
+
+  const results = await installSkills(skills, installOptions)
+  showInstallResults(results)
+
+  if (results.some((r) => !r.success)) {
+    process.exit(1)
+  }
+}

package/src/cli/list.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk'
+
+import { getRemoteCategories, getRemoteSkills } from '../services/registry'
+
+export async function runCliList(): Promise<void> {
+  console.log(chalk.blue('⏳ Fetching skills registry...'))
+
+  const [skills, categories] = await Promise.all([getRemoteSkills(), getRemoteCategories()])
+
+  if (skills.length === 0) {
+    console.log(chalk.yellow('No skills found in the registry.'))
+    return
+  }
+
+  const categoryMap = new Map(categories.map((c) => [c.id, c.name]))
+
+  // Group skills by category
+  const byCategory = new Map<string, typeof skills>()
+  for (const skill of skills) {
+    const cat = skill.category ?? 'uncategorized'
+    if (!byCategory.has(cat)) byCategory.set(cat, [])
+    byCategory.get(cat)!.push(skill)
+  }
+
+  console.log(chalk.bold(`\n📦 Available Skills (${skills.length} total)\n`))
+
+  for (const [catId, catSkills] of byCategory) {
+    const catName = categoryMap.get(catId) ?? catId
+    console.log(chalk.cyan.bold(`  ${catName}`))
+
+    for (const skill of catSkills) {
+      const name = chalk.white(skill.name.padEnd(36))
+      const desc = chalk.dim(skill.description ?? '')
+      console.log(`    ${name} ${desc}`)
+    }
+
+    console.log()
+  }
+
+  console.log(chalk.dim(`Run ${chalk.white('ai-tools install -s <skill-name>')} to install a skill.`))
+}

package/src/cli/remove.ts

@@ -0,0 +1,70 @@
+import chalk from 'chalk'
+
+import { removeSkill } from '../services/installer'
+import type { AgentType } from '../types'
+
+interface RemoveCliOptions {
+  skill?: string[]
+  agent?: string[]
+  global?: boolean
+  force?: boolean
+}
+
+export async function runCliRemove(options: RemoveCliOptions): Promise<void> {
+  if (!options.skill || options.skill.length === 0) {
+    console.error(chalk.red('❌ --skill is required in CLI mode'))
+    console.error(
+      chalk.dim('Usage: ai-tools remove --skill <name1> [name2...] [--agent <agents...>] [--global] [--force]'),
+    )
+    process.exit(1)
+  }
+
+  const skillNames = Array.isArray(options.skill) ? options.skill : [options.skill]
+  const agents = (options.agent || ['github-copilot', 'claude-code']) as AgentType[]
+
+  if (options.force) {
+    console.log(chalk.yellow('⚠️  Force mode enabled - bypassing lockfile check'))
+  }
+
+  console.log(chalk.blue(`⏳ Removing ${skillNames.length} skill(s) from ${agents.length} agent(s)...`))
+
+  let totalSuccess = 0
+  let totalFailed = 0
+  let hasLockfileError = false
+
+  for (const skillName of skillNames) {
+    const results = await removeSkill(skillName, agents, {
+      global: options.global,
+      force: options.force,
+    })
+
+    const successful = results.filter((r) => r.success)
+    const failed = results.filter((r) => !r.success)
+
+    if (successful.length > 0) {
+      console.log(chalk.green(`✅ ${skillName}: Removed from ${successful.length} agent(s)`))
+      successful.forEach((r) => console.log(chalk.dim(`  • ${r.agent}`)))
+      totalSuccess += successful.length
+    }
+
+    if (failed.length > 0) {
+      console.log(chalk.red(`❌ ${skillName}: Failed to remove from ${failed.length} agent(s)`))
+      failed.forEach((r) => console.log(chalk.dim(`  • ${r.agent}: ${r.error}`)))
+      totalFailed += failed.length
+
+      if (failed.some((r) => r.error?.includes('lockfile'))) {
+        hasLockfileError = true
+      }
+    }
+  }
+
+  console.log(chalk.dim(`\n${totalSuccess} succeeded, ${totalFailed} failed`))
+
+  if (hasLockfileError && !options.force) {
+    console.log(chalk.yellow('\n💡 Tip: Use --force to bypass lockfile check'))
+  }
+
+  if (totalFailed > 0) {
+    process.exit(1)
+  }
+}

package/src/cli/update.ts

@@ -0,0 +1,107 @@
+import chalk from 'chalk'
+import {
+  fetchRegistry,
+  forceDownloadSkill,
+  getDeprecatedMap,
+  getRemoteSkills,
+  getUpdatableSkills,
+  needsUpdate,
+} from '../services/registry'
+
+interface UpdateCliOptions {
+  skill?: string
+}
+
+export async function runCliUpdate(options: UpdateCliOptions): Promise<void> {
+  console.log(chalk.blue('⏳ Fetching latest registry...'))
+  await fetchRegistry(true)
+
+  if (options.skill) {
+    const outdated = await needsUpdate(options.skill)
+    if (!outdated) {
+      console.log(chalk.green(`✅ ${options.skill} is already up to date`))
+      return
+    }
+
+    console.log(chalk.blue(`⏳ Updating ${options.skill}...`))
+    const path = await forceDownloadSkill(options.skill)
+
+    if (path) {
+      console.log(chalk.green(`✅ Updated ${options.skill}`))
+    } else {
+      console.error(chalk.red(`❌ Failed to update ${options.skill}`))
+      process.exit(1)
+    }
+  } else {
+    const { readSkillLock } = await import('../services/lockfile')
+    const lock = await readSkillLock()
+    const installedNames = Object.keys(lock.skills)
+
+    if (installedNames.length === 0) {
+      console.log(chalk.yellow('No installed skills found. Run ai-tools install first.'))
+      return
+    }
+
+    const { toUpdate, upToDate } = await getUpdatableSkills(installedNames)
+
+    if (toUpdate.length === 0) {
+      console.log(chalk.green(`✅ All ${upToDate.length} installed skills are up to date`))
+      return
+    }
+
+    console.log(chalk.blue(`⏳ Updating ${toUpdate.length} of ${installedNames.length} skills...`))
+    let updated = 0
+    let failed = 0
+
+    for (const name of toUpdate) {
+      const path = await forceDownloadSkill(name)
+      if (path) {
+        updated++
+      } else {
+        failed++
+        console.error(chalk.red(`  ❌ Failed to update ${name}`))
+      }
+    }
+
+    console.log(
+      chalk.green(
+        `✅ ${updated} updated, ${upToDate.length} already up to date${failed > 0 ? chalk.red(`, ${failed} failed`) : ''}`,
+      ),
+    )
+
+    // Check for deprecated/orphaned skills
+    const deprecatedMap = await getDeprecatedMap()
+    const remoteSkills = await getRemoteSkills()
+    const registryNames = new Set(remoteSkills.map((s) => s.name))
+
+    const deprecated = installedNames.filter((name) => deprecatedMap.has(name) || !registryNames.has(name))
+
+    if (deprecated.length > 0) {
+      console.log('')
+      console.log(chalk.yellow(`⚠  ${deprecated.length} deprecated skill${deprecated.length > 1 ? 's' : ''} detected:`))
+
+      const renderers: Record<
+        'withEntry' | 'noEntry',
+        (name: string, entry?: { message: string; alternatives?: string[] }) => void
+      > = {
+        withEntry: (name, entry) => {
+          console.log(chalk.yellow(`  › ${name} — ${entry!.message}`))
+          if (entry!.alternatives?.length) {
+            console.log(chalk.dim(`    Try: ai-tools install --skill ${entry!.alternatives.join(', ')}`))
+          }
+        },
+        noEntry: (name) => {
+          console.log(chalk.yellow(`  › ${name} — no longer available in the registry`))
+        },
+      }
+
+      deprecated.forEach((name) => {
+        const entry = deprecatedMap.get(name)
+        const rendererKey = entry ? 'withEntry' : 'noEntry'
+        renderers[rendererKey](name, entry)
+      })
+
+      console.log(chalk.dim(`  Run: ai-tools remove --skill <name> to clean up`))
+    }
+  }
+}

package/src/components/AnimatedTransition.tsx

@@ -0,0 +1,42 @@
+import React, { useEffect, useState } from 'react'
+
+export interface AnimatedTransitionProps {
+  visible: boolean
+  duration?: number
+  children: React.ReactNode
+}
+
+export const AnimatedTransition: React.FC<AnimatedTransitionProps> = ({ visible, duration = 250, children }) => {
+  const [opacity, setOpacity] = useState(visible ? 1 : 0)
+
+  useEffect(() => {
+    if ((visible && opacity === 1) || (!visible && opacity === 0)) return
+
+    const startTime = Date.now()
+    const startOpacity = opacity
+    const targetOpacity = visible ? 1 : 0
+    const frameDuration = 16
+
+    const interval = setInterval(() => {
+      const now = Date.now()
+      const elapsed = now - startTime
+      const progress = Math.min(elapsed / duration, 1)
+      const currentOpacity = startOpacity + (visible ? progress : -progress) * Math.abs(targetOpacity - startOpacity)
+      const clampedOpacity = Math.max(0, Math.min(1, currentOpacity))
+
+      setOpacity(clampedOpacity)
+
+      if (progress >= 1) {
+        clearInterval(interval)
+        setOpacity(targetOpacity)
+      }
+    }, frameDuration)
+
+    return () => {
+      clearInterval(interval)
+    }
+  }, [visible, duration])
+
+  if (!visible && opacity <= 0.05) return null
+  return <>{children}</>
+}