@siliconoid/agentkit 0.1.0

package/lib/log.mjs

@@ -0,0 +1,89 @@
+import pc from 'picocolors'
+
+/** Verbosity level: 0=quiet, 1=normal, 2=verbose */
+let verbosity = 1
+
+export function setVerbosity(level) {
+  verbosity = level
+}
+
+export function getVerbosity() {
+  return verbosity
+}
+
+export const log = {
+  /** Success message (green) */
+  success(msg) {
+    if (verbosity >= 1) console.log(pc.green(msg))
+  },
+
+  /** Info message (cyan) */
+  info(msg) {
+    if (verbosity >= 1) console.log(pc.cyan(msg))
+  },
+
+  /** Warning message (yellow) */
+  warn(msg) {
+    if (verbosity >= 1) console.log(pc.yellow(`⚠ ${msg}`))
+  },
+
+  /** Error message (red) */
+  error(msg) {
+    console.error(pc.red(`✘ ${msg}`))
+  },
+
+  /** Plain message (no color) */
+  plain(msg) {
+    if (verbosity >= 1) console.log(msg)
+  },
+
+  /** Verbose message (dim, only shown with --verbose) */
+  verbose(msg) {
+    if (verbosity >= 2) console.log(pc.dim(msg))
+  },
+
+  /** File created */
+  created(path) {
+    if (verbosity >= 1) console.log(`  ${pc.green('+')} ${path}`)
+  },
+
+  /** File updated/overwritten */
+  updated(path) {
+    if (verbosity >= 1) console.log(`  ${pc.yellow('~')} ${path}`)
+  },
+
+  /** File skipped */
+  skipped(path) {
+    if (verbosity >= 2) console.log(`  ${pc.dim('-')} ${pc.dim(path)}`)
+  },
+
+  /** File removed */
+  removed(path) {
+    if (verbosity >= 1) console.log(`  ${pc.red('×')} ${path}`)
+  },
+
+  /** Section header */
+  header(msg) {
+    if (verbosity >= 1) console.log(pc.bold(`\n${msg}`))
+  },
+
+  /** Summary box */
+  summary(title, lines) {
+    if (verbosity < 1) return
+    const sep = pc.dim('═'.repeat(50))
+    console.log(`\n${sep}`)
+    console.log(pc.bold(pc.green(` ${title}`)))
+    console.log(sep)
+    for (const line of lines) {
+      console.log(`  ${line}`)
+    }
+    console.log('')
+  },
+
+  /** Dim text */
+  dim(msg) {
+    if (verbosity >= 1) console.log(pc.dim(msg))
+  },
+}
+
+export default log

package/lib/prompts.mjs

@@ -0,0 +1,348 @@
+import { input, select, checkbox, confirm } from '@inquirer/prompts'
+import { existsSync, readFileSync } from 'fs'
+import { join, basename } from 'path'
+import { PLATFORMS, WORKFLOW_PACKS, detectPlatforms, discoverSkillPacks } from './utils.mjs'
+
+// ---------------------------------------------------------------------------
+// Auto-detection helpers
+// ---------------------------------------------------------------------------
+
+/** Read package.json fields */
+function readPkg(projectRoot) {
+  const pkgPath = join(projectRoot, 'package.json')
+  if (!existsSync(pkgPath)) return {}
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+/** Detect framework from package.json dependencies */
+export function detectFramework(projectRoot) {
+  const pkg = readPkg(projectRoot)
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+
+  if (deps.next) {
+    // Check for app router: app/ directory exists
+    if (existsSync(join(projectRoot, 'app')) || existsSync(join(projectRoot, 'src', 'app'))) {
+      return 'nextjs-app'
+    }
+    return 'nextjs-pages'
+  }
+  if (deps.vite || deps['@vitejs/plugin-react']) return 'react-spa'
+  if (deps.vue) return 'vue'
+  if (deps.express || deps.fastify || deps.koa || deps['@nestjs/core']) return 'nodejs'
+  if (deps.react) return 'react-spa'
+  return null
+}
+
+/** Detect package manager from lockfile */
+function detectPackageManager(projectRoot) {
+  if (existsSync(join(projectRoot, 'bun.lockb')) || existsSync(join(projectRoot, 'bun.lock'))) return 'bun'
+  if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(projectRoot, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+/** Detect framework version from deps */
+function detectFrameworkVersion(deps, devDeps) {
+  if (deps.next) return deps.next
+  if (deps.vue) return deps.vue
+  if (devDeps.vite) return devDeps.vite
+  if (deps.express) return deps.express
+  if (deps.fastify) return deps.fastify
+  if (deps.koa) return deps.koa
+  if (deps['@nestjs/core']) return deps['@nestjs/core']
+  return '—'
+}
+
+/** Detect first matching dep from a map */
+function detectFromDeps(deps, map) {
+  for (const [pkg, label] of Object.entries(map)) {
+    if (deps[pkg]) return label
+  }
+  return '—'
+}
+
+/** Detect CSS approach from deps + files */
+function detectCssApproach(allDeps, projectRoot) {
+  const approaches = []
+  if (allDeps.tailwindcss) approaches.push('Tailwind CSS')
+  if (allDeps['styled-components']) approaches.push('styled-components')
+  if (allDeps['@emotion/react'] || allDeps['@emotion/styled']) approaches.push('Emotion')
+  if (allDeps.sass || allDeps['sass-embedded']) approaches.push('SCSS')
+  if (allDeps.less) approaches.push('Less')
+  // Check for CSS Modules usage (common in Next.js/Vite projects)
+  if (approaches.length === 0 || allDeps.sass || allDeps['sass-embedded']) {
+    // CSS Modules is often used alongside SCSS but doesn't have a dep
+  }
+  return approaches.length > 0 ? approaches.join(' + ') : '—'
+}
+
+/** Detect build tool */
+function detectBuildTool(allDeps) {
+  if (allDeps.vite) return 'Vite'
+  if (allDeps.next) return 'Next.js (Webpack/Turbopack)'
+  if (allDeps.webpack) return 'Webpack'
+  if (allDeps.esbuild) return 'esbuild'
+  if (allDeps.turbopack || allDeps.turbo) return 'Turbopack'
+  if (allDeps.rollup) return 'Rollup'
+  if (allDeps.parcel) return 'Parcel'
+  return '—'
+}
+
+/** Auto-detect everything we can from the project */
+export function autoDetect(projectRoot) {
+  const pkg = readPkg(projectRoot)
+  const existingPlatforms = detectPlatforms(projectRoot)
+  const deps = { ...pkg.dependencies }
+  const devDeps = { ...pkg.devDependencies }
+  const allDeps = { ...deps, ...devDeps }
+
+  return {
+    // Existing
+    projectName: pkg.name || basename(projectRoot),
+    projectDescription: pkg.description || null,
+    framework: detectFramework(projectRoot),
+    platforms: existingPlatforms.length > 0 ? existingPlatforms : null,
+
+    // New: package manager (check lockfile existence)
+    packageManager: detectPackageManager(projectRoot),
+
+    // New: language
+    primaryLanguage: existsSync(join(projectRoot, 'tsconfig.json')) ? 'TypeScript' : 'JavaScript',
+    typescriptVersion: devDeps.typescript || allDeps.typescript || '—',
+
+    // New: framework version
+    frameworkVersion: detectFrameworkVersion(deps, devDeps),
+
+    // New: React version
+    reactVersion: deps.react || '—',
+
+    // New: state management
+    stateManagement: detectFromDeps(allDeps, {
+      '@reduxjs/toolkit': 'Redux Toolkit',
+      'redux': 'Redux',
+      'zustand': 'Zustand',
+      'pinia': 'Pinia',
+      'jotai': 'Jotai',
+      'mobx': 'MobX',
+      'recoil': 'Recoil',
+      'vuex': 'Vuex',
+    }),
+
+    // New: UI library
+    uiLibrary: detectFromDeps(allDeps, {
+      'antd': 'Ant Design',
+      '@mui/material': 'Material UI',
+      'element-plus': 'Element Plus',
+      '@chakra-ui/react': 'Chakra UI',
+      '@mantine/core': 'Mantine',
+      'primereact': 'PrimeReact',
+      '@arco-design/web-react': 'Arco Design',
+    }),
+
+    // New: CSS approach
+    cssApproach: detectCssApproach(allDeps, projectRoot),
+
+    // New: HTTP client
+    httpClient: detectFromDeps(allDeps, {
+      'axios': 'Axios',
+      '@tanstack/react-query': 'TanStack Query',
+      'swr': 'SWR',
+      'ky': 'Ky',
+      'got': 'Got',
+    }),
+
+    // New: testing framework
+    testingFramework: detectFromDeps(devDeps, {
+      'vitest': 'Vitest',
+      'jest': 'Jest',
+      'mocha': 'Mocha',
+      '@playwright/test': 'Playwright',
+      'cypress': 'Cypress',
+    }),
+
+    // New: build tool
+    buildTool: detectBuildTool(allDeps),
+
+    // New: linter
+    linter: detectFromDeps(devDeps, {
+      '@biomejs/biome': 'Biome',
+      'eslint': 'ESLint',
+      'oxlint': 'Oxlint',
+    }),
+
+    // New: node version
+    nodeVersion: pkg.engines?.node || '—',
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Interactive prompts
+// ---------------------------------------------------------------------------
+
+export async function askProjectName(projectRoot) {
+  const pkg = readPkg(projectRoot)
+  return input({
+    message: 'Project name:',
+    default: pkg.name || basename(projectRoot),
+  })
+}
+
+export async function askProjectDescription(detected) {
+  return input({
+    message: 'Short project description:',
+    default: detected || 'A software project.',
+  })
+}
+
+export const FRAMEWORK_LABELS = {
+  'nextjs-pages': 'Next.js (Pages Router)',
+  'nextjs-app': 'Next.js (App Router)',
+  'react-spa': 'React SPA (Vite/CRA)',
+  'vue': 'Vue',
+  'nodejs': 'Node.js (backend)',
+  'custom': 'Custom / Other',
+}
+
+export async function askFramework(detected) {
+  const choices = Object.entries(FRAMEWORK_LABELS).map(([value, name]) => ({
+    name: value === detected ? `${name} (detected)` : name,
+    value,
+  }))
+
+  return select({
+    message: 'Framework:',
+    choices,
+    default: detected || undefined,
+  })
+}
+
+export async function askPlatforms(detected) {
+  return checkbox({
+    message: 'Which AI platforms do you use?',
+    choices: PLATFORMS.map(p => ({
+      name: p.name,
+      value: p.id,
+      checked: detected
+        ? detected.includes(p.id)
+        : p.id === 'claude',
+    })),
+    required: true,
+  })
+}
+
+export async function askWorkflowPacks() {
+  return checkbox({
+    message: 'Install workflow packs? (space to toggle, enter to confirm)',
+    choices: WORKFLOW_PACKS.map(w => ({
+      name: `${w.name} — ${w.description}`,
+      value: w.id,
+      checked: true,
+    })),
+  })
+}
+
+export async function askSkillPacks() {
+  const packs = discoverSkillPacks()
+  if (packs.length === 0) return []
+
+  // Truncate long descriptions for display
+  const truncate = (str, max = 80) => str.length > max ? str.slice(0, max - 1) + '…' : str
+
+  return checkbox({
+    message: 'Install skill packs? (space to toggle, enter to confirm)',
+    choices: packs.map(s => ({
+      name: `${s.id} — ${truncate(s.description)}`,
+      value: s.id,
+      checked: true,
+    })),
+  })
+}
+
+export async function askOverwrite(fileName) {
+  return confirm({
+    message: `${fileName} already exists. Overwrite?`,
+    default: false,
+  })
+}
+
+/**
+ * Show auto-detected values and ask user to confirm or customize.
+ * Returns the final config values.
+ */
+export async function runInteractivePrompts(projectRoot) {
+  const detected = autoDetect(projectRoot)
+
+  // Show what was detected
+  console.log('  Detected:')
+  console.log(`    Name:        ${detected.projectName}`)
+  if (detected.projectDescription) {
+    console.log(`    Description: ${detected.projectDescription}`)
+  }
+  if (detected.framework) {
+    console.log(`    Framework:   ${FRAMEWORK_LABELS[detected.framework] || detected.framework}`)
+  }
+  if (detected.platforms) {
+    console.log(`    Platforms:   ${detected.platforms.join(', ')}`)
+  }
+  console.log('')
+
+  const useDetected = await confirm({
+    message: 'Use detected settings?',
+    default: true,
+  })
+
+  let projectName, projectDescription, framework, platforms
+
+  if (useDetected) {
+    projectName = detected.projectName
+    projectDescription = detected.projectDescription || await askProjectDescription(null)
+    framework = detected.framework || await askFramework(null)
+    platforms = detected.platforms && detected.platforms.length > 0
+      ? detected.platforms
+      : await askPlatforms(null)
+  } else {
+    projectName = await askProjectName(projectRoot)
+    projectDescription = await askProjectDescription(detected.projectDescription)
+    framework = await askFramework(detected.framework)
+    platforms = await askPlatforms(detected.platforms)
+  }
+
+  const workflowPacks = await askWorkflowPacks()
+  const skillPacks = await askSkillPacks()
+
+  return { projectName, projectDescription, framework, platforms, workflowPacks, skillPacks }
+}
+
+/**
+ * Recommend skill packs based on detected project features.
+ * @param {object} detected - Result of autoDetect()
+ * @returns {string[]} - Recommended skill pack IDs
+ */
+export function recommendSkillPacks(detected) {
+  const packs = ['security-best-practices']
+  if (detected.framework?.startsWith('nextjs')) packs.push('next-best-practices')
+  if (detected.reactVersion && detected.reactVersion !== '—') {
+    packs.push('frontend-design', 'vercel-react-best-practices', 'vercel-composition-patterns')
+  }
+  if ((detected.uiLibrary && detected.uiLibrary !== '—') || (detected.cssApproach && detected.cssApproach !== '—')) {
+    packs.push('web-design-guidelines')
+  }
+  return packs
+}
+
+/** Get human-readable framework display name for templates */
+export function frameworkDisplayName(framework) {
+  const map = {
+    'nextjs-pages': 'Next.js (Pages Router)',
+    'nextjs-app': 'Next.js (App Router)',
+    'react-spa': 'React',
+    'vue': 'Vue',
+    'nodejs': 'Node.js',
+    'custom': '—',
+  }
+  return map[framework] || framework || '—'
+}