@siliconoid/agentkit 0.1.0

package/lib/commands/init.mjs

@@ -0,0 +1,261 @@
+import { basename, join } from 'path'
+import { existsSync, readdirSync, unlinkSync, rmSync } from 'fs'
+import { findProjectRoot, writeConfig, readConfig, PLATFORMS, WORKFLOW_PACKS, SKILL_BUNDLES, discoverSkillPacks } from '../utils.mjs'
+import {
+  autoDetect, runInteractivePrompts,
+  recommendSkillPacks, frameworkDisplayName,
+} from '../prompts.mjs'
+import {
+  scaffoldBase, scaffoldFramework, scaffoldPlatforms,
+  scaffoldWorkflows, scaffoldSkills, scaffoldSkillBundles,
+  runTemplateReplace, generateQuickStart,
+} from '../scaffold.mjs'
+import { runSync } from './sync.mjs'
+import log from '../log.mjs'
+
+export async function runInit(opts = {}) {
+  try {
+    const projectRoot = findProjectRoot()
+    log.info(`\nInitializing AI project rules in: ${projectRoot}\n`)
+
+    // Check if already initialized
+    const existing = readConfig(projectRoot)
+    if (existing && !opts.force) {
+      log.warn('Project already initialized (.ai/agentkit.json exists).')
+      log.plain('Use `agentkit update` to update templates.')
+      log.plain('Use `agentkit init --force` to re-initialize.\n')
+      return
+    }
+
+    // Gather configuration
+    let projectName, projectDescription, framework, platforms, workflowPacks, skillPacks, skillBundles
+
+    if (opts.smart) {
+      // --smart: zero-question fully auto-detected init
+      const detected = autoDetect(projectRoot)
+      projectName = detected.projectName || basename(projectRoot)
+      projectDescription = detected.projectDescription || 'A software project.'
+      framework = detected.framework || 'custom'
+      // Only install detected platforms, fallback to claude
+      platforms = detected.platforms && detected.platforms.length > 0
+        ? detected.platforms
+        : ['claude']
+      // Smart skill pack recommendations
+      skillPacks = recommendSkillPacks(detected).filter(id =>
+        discoverSkillPacks().some(p => p.id === id)
+      )
+      workflowPacks = WORKFLOW_PACKS.map(w => w.id)
+      skillBundles = SKILL_BUNDLES.map(b => b.id)
+
+      log.info('  Smart mode: auto-detecting project configuration...')
+      log.plain(`    Name:         ${projectName}`)
+      log.plain(`    Framework:    ${framework}`)
+      log.plain(`    Language:     ${detected.primaryLanguage}`)
+      log.plain(`    Platforms:    ${platforms.join(', ')}`)
+      log.plain(`    Skill packs:  ${skillPacks.join(', ') || 'none'}`)
+      log.plain(`    Bundles:      ${skillBundles.join(', ') || 'none'}`)
+      log.plain('')
+    } else if (opts.minimal) {
+      // --minimal: stripped-down init
+      const detected = autoDetect(projectRoot)
+      projectName = detected.projectName || basename(projectRoot)
+      projectDescription = detected.projectDescription || 'A software project.'
+      framework = detected.framework || 'custom'
+      platforms = detected.platforms && detected.platforms.length > 0
+        ? detected.platforms
+        : ['claude']
+      workflowPacks = []
+      skillPacks = []
+      skillBundles = []
+    } else if (opts.yes) {
+      // -y: Auto-detect as much as possible, fill remaining with defaults
+      const detected = autoDetect(projectRoot)
+      projectName = detected.projectName || basename(projectRoot)
+      projectDescription = detected.projectDescription || 'A software project.'
+      framework = detected.framework || 'custom'
+      platforms = PLATFORMS.map(p => p.id)
+      workflowPacks = WORKFLOW_PACKS.map(w => w.id)
+      skillPacks = discoverSkillPacks().map(s => s.id)
+      skillBundles = SKILL_BUNDLES.map(b => b.id)
+    } else {
+      // Interactive flow with auto-detection
+      const answers = await runInteractivePrompts(projectRoot)
+      projectName = answers.projectName
+      projectDescription = answers.projectDescription
+      framework = answers.framework
+      platforms = answers.platforms
+      workflowPacks = answers.workflowPacks
+      skillPacks = answers.skillPacks
+      skillBundles = answers.skillBundles || SKILL_BUNDLES.map(b => b.id)
+    }
+
+    // Build extended vars from auto-detection for template replacement
+    // Always run autoDetect so tech stack vars are populated in all modes
+    const detected = autoDetect(projectRoot)
+    const vars = {
+      projectName,
+      projectDescription,
+      framework,
+      frameworkDisplay: frameworkDisplayName(framework),
+      frameworkVersion: detected.frameworkVersion || '—',
+      primaryLanguage: detected.primaryLanguage || 'TypeScript',
+      typescriptVersion: detected.typescriptVersion || '—',
+      reactVersion: detected.reactVersion || '—',
+      stateManagement: detected.stateManagement || '—',
+      uiLibrary: detected.uiLibrary || '—',
+      cssApproach: detected.cssApproach || '—',
+      httpClient: detected.httpClient || '—',
+      testingFramework: detected.testingFramework || '—',
+      buildTool: detected.buildTool || '—',
+      linter: detected.linter || '—',
+      packageManager: detected.packageManager || 'npm',
+      nodeVersion: detected.nodeVersion || '—',
+    }
+
+    // --dry-run: show what would be created
+    if (opts.dryRun) {
+      log.header('DRY RUN — the following would be created:')
+      log.plain(`  .ai/rules/ (13 rule files)`)
+      log.plain(`  .ai/skills/ (3 portable skills: adr, devlog, wrap-up)`)
+      log.plain(`  .ai/decisions/, .ai/changelog/, .ai/memory/`)
+      log.plain(`  .specs/`)
+      if (framework !== 'custom') log.plain(`  Framework overrides: ${framework}`)
+      for (const p of platforms) {
+        const plat = PLATFORMS.find(x => x.id === p)
+        if (plat) log.plain(`  ${plat.rootFile}`)
+      }
+      if (workflowPacks.length > 0) log.plain(`  Workflow packs: ${workflowPacks.join(', ')}`)
+      if (skillPacks.length > 0) log.plain(`  Skill packs: ${skillPacks.join(', ')}`)
+      log.plain(`  .ai/agentkit.json`)
+      log.plain('')
+      return
+    }
+
+    // Step 1: Scaffold base .ai/ structure
+    log.header('Creating .ai/ structure...')
+    const baseFiles = scaffoldBase(projectRoot, vars)
+    baseFiles.forEach(f => log.created(f))
+
+    // Step 2: Apply framework overrides
+    if (framework !== 'custom') {
+      log.header(`Applying ${framework} framework rules...`)
+      const fwFiles = scaffoldFramework(projectRoot, framework, vars)
+      fwFiles.forEach(f => log.updated(f))
+    }
+
+    // Step 2b: Minimal mode cleanup — keep only core rules and remove auxiliary dirs
+    if (opts.minimal) {
+      const coreRulePrefixes = ['01-', '03-', '06-', '07-', '10-']
+      const rulesDir = join(projectRoot, '.ai', 'rules')
+      if (existsSync(rulesDir)) {
+        for (const file of readdirSync(rulesDir)) {
+          if (!file.endsWith('.md')) continue
+          const isCore = coreRulePrefixes.some(p => file.startsWith(p))
+          if (!isCore) {
+            unlinkSync(join(rulesDir, file))
+          }
+        }
+      }
+      // Remove auxiliary directories not needed in minimal mode
+      const skipDirs = [
+        join(projectRoot, '.ai', 'skills'),
+        join(projectRoot, '.ai', 'decisions'),
+        join(projectRoot, '.ai', 'changelog'),
+        join(projectRoot, '.ai', 'memory'),
+        join(projectRoot, '.ai', 'scripts'),
+        join(projectRoot, '.specs'),
+      ]
+      for (const dir of skipDirs) {
+        if (existsSync(dir)) {
+          rmSync(dir, { recursive: true, force: true })
+        }
+      }
+      log.info('  Minimal mode: kept core rules (01, 03, 06, 07, 10), removed extras')
+    }
+
+    // Step 3: Generate platform root docs
+    log.header('Generating platform files...')
+    const platFiles = await scaffoldPlatforms(projectRoot, platforms, vars)
+    platFiles.forEach(f => log.created(f))
+
+    // Step 4: Template replacement
+    runTemplateReplace(projectRoot, vars)
+
+    // Step 5: Install workflow packs
+    if (workflowPacks.length > 0) {
+      log.header(`Installing workflow packs: ${workflowPacks.join(', ')}...`)
+      const wfFiles = scaffoldWorkflows(projectRoot, platforms, workflowPacks, vars)
+      log.success(`  ${wfFiles.length} workflow command files installed`)
+    }
+
+    // Step 6: Install skill packs
+    if (skillPacks.length > 0) {
+      log.header('Installing skill packs...')
+      const skillFiles = scaffoldSkills(projectRoot, platforms, skillPacks)
+      const platCount = platforms.filter(p => ['claude', 'codex', 'gemini', 'antigravity'].includes(p)).length
+      log.success(`  ${skillFiles.length} skill files across ${platCount} platform(s)`)
+    }
+
+    // Step 6b: Install skill bundles (e.g. Superpowers)
+    if (skillBundles.length > 0) {
+      for (const bundleId of skillBundles) {
+        const bundle = SKILL_BUNDLES.find(b => b.id === bundleId)
+        if (!bundle) continue
+        log.header(`Installing ${bundle.name}...`)
+        const bundleFiles = scaffoldSkillBundles(projectRoot, platforms, [bundleId])
+        log.success(`  ${bundleFiles.length} files (14 skills + agents)`)
+      }
+    }
+
+    // Step 7: Write config
+    const config = {
+      version: '0.1.0',
+      projectName,
+      projectDescription,
+      framework,
+      platforms,
+      workflowPacks,
+      skillPacks,
+      skillBundles,
+      detected: {
+        packageManager: vars.packageManager,
+        primaryLanguage: vars.primaryLanguage,
+        buildTool: vars.buildTool,
+      },
+    }
+    writeConfig(projectRoot, config)
+    log.created('.ai/agentkit.json')
+
+    // Step 8: Sync portable skills (adr, devlog, wrap-up) to platforms
+    if (!opts.minimal) {
+      log.header('Syncing portable skills to platforms...')
+      await runSync({ _projectRoot: projectRoot, _platforms: platforms, _vars: vars })
+    }
+
+    // Generate Quick Start guide
+    if (!opts.minimal) {
+      generateQuickStart(projectRoot, vars, framework)
+      log.created('.ai/QUICK-START.md')
+    }
+
+    // Summary
+    log.summary('AI project rules initialized successfully!', [
+      `Project:      ${projectName}`,
+      `Framework:    ${framework}`,
+      `Platforms:    ${platforms.join(', ')}`,
+      `Workflows:    ${workflowPacks.length > 0 ? workflowPacks.join(', ') : 'none'}`,
+      `Skill packs:  ${skillPacks.length > 0 ? skillPacks.join(', ') : 'none'}`,
+      `Bundles:      ${skillBundles.length > 0 ? skillBundles.join(', ') : 'none'}`,
+      `Skills:       adr, devlog, wrap-up`,
+      '',
+      'Next steps:',
+      '  1. Review and customize files in .ai/rules/',
+      '  2. Run `npx agentkit sync` after modifying skills',
+      '  3. Run `npx agentkit add-skill <name>` to create new skills',
+    ])
+  } catch (err) {
+    log.error(`Init failed: ${err.message}`)
+    log.verbose(err.stack)
+    process.exit(1)
+  }
+}

package/lib/commands/install.mjs

@@ -0,0 +1,236 @@
+import { join, resolve, basename } from 'path'
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmSync, cpSync } from 'fs'
+import { execSync } from 'child_process'
+import { findProjectRoot, readConfig, writeConfig, ensureDir } from '../utils.mjs'
+import { runSync } from './sync.mjs'
+import log from '../log.mjs'
+import pc from 'picocolors'
+
+/**
+ * Install a package (rules, skills, skill-packs) from local path or npm.
+ * @param {string} source - Local path or npm package name
+ * @param {object} opts - Command options
+ */
+export async function runInstall(source, opts = {}) {
+  try {
+    const projectRoot = findProjectRoot()
+    const config = readConfig(projectRoot)
+
+    if (!config) {
+      log.error('No .ai/agentkit.json found. Run `agentkit init` first.')
+      process.exit(1)
+    }
+
+    log.info(`\nInstalling package: ${source}\n`)
+
+    // Resolve package source
+    let packageDir
+    let packageSource
+    let cleanup = null
+
+    if (isLocalPath(source)) {
+      // Local directory
+      packageDir = resolve(source)
+      packageSource = `local:${packageDir}`
+      if (!existsSync(packageDir)) {
+        log.error(`Directory not found: ${packageDir}`)
+        process.exit(1)
+      }
+    } else {
+      // npm package — download to temp dir
+      packageDir = downloadNpmPackage(source)
+      packageSource = `npm:${source}`
+      cleanup = () => {
+        try { rmSync(packageDir, { recursive: true, force: true }) } catch {}
+      }
+    }
+
+    try {
+      // Read package metadata
+      const meta = readPackageMeta(packageDir)
+      const packageName = meta.name || basename(packageDir)
+      const packageVersion = meta.version || '0.0.0'
+      const aiRules = meta['ai-rules'] || {}
+      const packageType = aiRules.type || detectPackageType(packageDir)
+
+      log.plain(`  Package:  ${pc.bold(packageName)} v${packageVersion}`)
+      log.plain(`  Type:     ${packageType}`)
+      log.plain(`  Source:   ${packageSource}`)
+      log.plain('')
+
+      const installedFiles = []
+
+      // Install rules
+      const rulesDir = join(packageDir, 'rules')
+      if (existsSync(rulesDir)) {
+        log.header('Installing rules...')
+        const destRulesDir = join(projectRoot, '.ai', 'rules')
+        ensureDir(destRulesDir)
+        const ruleFiles = readdirSync(rulesDir).filter(f => f.endsWith('.md'))
+        for (const file of ruleFiles) {
+          const destPath = join(destRulesDir, file)
+          const srcContent = readFileSync(join(rulesDir, file), 'utf8')
+          if (existsSync(destPath) && !opts.force) {
+            log.warn(`Skipping existing rule: ${file} (use --force to overwrite)`)
+          } else {
+            writeFileSync(destPath, srcContent)
+            log.created(`rules/${file}`)
+            installedFiles.push(`rules/${file}`)
+          }
+        }
+      }
+
+      // Install skills
+      const skillsDir = join(packageDir, 'skills')
+      if (existsSync(skillsDir)) {
+        log.header('Installing skills...')
+        const destSkillsDir = join(projectRoot, '.ai', 'skills')
+        ensureDir(destSkillsDir)
+        const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
+        for (const dir of skillDirs) {
+          const srcSkill = join(skillsDir, dir.name)
+          const destSkill = join(destSkillsDir, dir.name)
+          if (existsSync(destSkill) && !opts.force) {
+            log.warn(`Skipping existing skill: ${dir.name} (use --force to overwrite)`)
+          } else {
+            ensureDir(destSkill)
+            copyRecursive(srcSkill, destSkill)
+            log.created(`skills/${dir.name}/`)
+            installedFiles.push(`skills/${dir.name}/`)
+          }
+        }
+      }
+
+      // Install skill pack files (SKILL.md at root with subdirectories)
+      const skillMd = join(packageDir, 'SKILL.md')
+      if (existsSync(skillMd) && !existsSync(skillsDir)) {
+        // Single skill pack — the entire package is a skill
+        log.header('Installing as skill pack...')
+        const destSkillDir = join(projectRoot, '.ai', 'skills', packageName)
+        if (existsSync(destSkillDir) && !opts.force) {
+          log.warn(`Skipping existing skill: ${packageName} (use --force to overwrite)`)
+        } else {
+          ensureDir(destSkillDir)
+          copyRecursive(packageDir, destSkillDir, ['node_modules', 'package.json', '.git', '.npmignore'])
+          log.created(`skills/${packageName}/`)
+          installedFiles.push(`skills/${packageName}/`)
+        }
+      }
+
+      if (installedFiles.length === 0) {
+        log.warn('No rules or skills found in package. Nothing installed.')
+        return
+      }
+
+      // Register in config
+      if (!config.packages) config.packages = {}
+      config.packages[packageName] = {
+        version: packageVersion,
+        source: packageSource,
+        type: packageType,
+        files: installedFiles,
+        installedAt: new Date().toISOString(),
+      }
+      writeConfig(projectRoot, config)
+
+      // Auto-sync to platforms
+      log.header('Syncing to platforms...')
+      await runSync({ _projectRoot: projectRoot, _platforms: config.platforms })
+
+      log.summary(`Package "${packageName}" installed successfully!`, [
+        `Type:     ${packageType}`,
+        `Files:    ${installedFiles.length} installed`,
+        `Source:   ${packageSource}`,
+        '',
+        'Run `agentkit list` to see installed packages.',
+      ])
+    } finally {
+      if (cleanup) cleanup()
+    }
+  } catch (err) {
+    log.error(`Install failed: ${err.message}`)
+    log.verbose(err.stack)
+    process.exit(1)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isLocalPath(source) {
+  return source.startsWith('.') || source.startsWith('/') || source.startsWith('~')
+}
+
+function readPackageMeta(dir) {
+  const pkgPath = join(dir, 'package.json')
+  if (!existsSync(pkgPath)) return {}
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function detectPackageType(dir) {
+  const hasRules = existsSync(join(dir, 'rules'))
+  const hasSkills = existsSync(join(dir, 'skills'))
+  const hasSkillMd = existsSync(join(dir, 'SKILL.md'))
+  if (hasRules && (hasSkills || hasSkillMd)) return 'mixed'
+  if (hasRules) return 'rule-pack'
+  return 'skill-pack'
+}
+
+function downloadNpmPackage(packageName) {
+  const tmpDir = join(process.env.TMPDIR || '/tmp', `ai-rules-install-${Date.now()}`)
+  mkdirSync(tmpDir, { recursive: true })
+
+  try {
+    log.plain(`  Downloading ${packageName}...`)
+    // Use npm pack to download the tarball
+    execSync(`npm pack ${packageName} --pack-destination "${tmpDir}"`, {
+      cwd: tmpDir,
+      stdio: 'pipe',
+    })
+
+    // Find the tarball
+    const tarballs = readdirSync(tmpDir).filter(f => f.endsWith('.tgz'))
+    if (tarballs.length === 0) {
+      throw new Error(`Failed to download package: ${packageName}`)
+    }
+
+    // Extract tarball
+    const tarball = join(tmpDir, tarballs[0])
+    const extractDir = join(tmpDir, 'extracted')
+    mkdirSync(extractDir, { recursive: true })
+    execSync(`tar -xzf "${tarball}" -C "${extractDir}"`, { stdio: 'pipe' })
+
+    // npm pack extracts to a 'package/' subdirectory
+    const packageDir = join(extractDir, 'package')
+    if (existsSync(packageDir)) return packageDir
+
+    // Fallback: first directory in extracted
+    const dirs = readdirSync(extractDir, { withFileTypes: true }).filter(d => d.isDirectory())
+    if (dirs.length > 0) return join(extractDir, dirs[0].name)
+
+    return extractDir
+  } catch (err) {
+    rmSync(tmpDir, { recursive: true, force: true })
+    throw new Error(`Failed to download npm package "${packageName}": ${err.message}`)
+  }
+}
+
+function copyRecursive(src, dest, exclude = []) {
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    if (exclude.includes(entry.name)) continue
+    const srcPath = join(src, entry.name)
+    const destPath = join(dest, entry.name)
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true })
+      copyRecursive(srcPath, destPath, exclude)
+    } else {
+      writeFileSync(destPath, readFileSync(srcPath))
+    }
+  }
+}

package/lib/commands/list.mjs

@@ -0,0 +1,105 @@
+import { join } from 'path'
+import { existsSync, readdirSync, readFileSync } from 'fs'
+import { findProjectRoot, readConfig, PLATFORMS, WORKFLOW_PACKS, discoverSkills, discoverSkillPacks } from '../utils.mjs'
+import log from '../log.mjs'
+import pc from 'picocolors'
+
+export async function runList(opts = {}) {
+  const projectRoot = findProjectRoot()
+  const config = readConfig(projectRoot)
+
+  if (!config) {
+    log.error('No .ai/agentkit.json found. Run `agentkit init` first.')
+    process.exit(1)
+  }
+
+  log.header('Project Configuration')
+  log.plain(`  Name:        ${pc.bold(config.projectName)}`)
+  log.plain(`  Description: ${config.projectDescription || pc.dim('(none)')}`)
+  log.plain(`  Framework:   ${pc.cyan(config.framework)}`)
+  log.plain(`  Version:     ${config.version}`)
+
+  // Platforms
+  log.header('Platforms')
+  for (const p of PLATFORMS) {
+    const enabled = config.platforms.includes(p.id)
+    const fileExists = existsSync(join(projectRoot, p.rootFile))
+    const status = enabled
+      ? (fileExists ? pc.green('✓') : pc.yellow('⚠ missing root file'))
+      : pc.dim('·')
+    log.plain(`  ${status} ${enabled ? pc.bold(p.name) : pc.dim(p.name)} ${pc.dim(`(${p.rootFile})`)}`)
+  }
+
+  // Portable Skills
+  const skills = discoverSkills(projectRoot)
+  log.header('Portable Skills')
+  if (skills.length > 0) {
+    skills.forEach(s => log.plain(`  ${pc.green('✓')} ${s.name} — ${s.manifest.description || ''}`))
+  } else {
+    log.dim('  No skills found in .ai/skills/')
+  }
+
+  // Skill Packs
+  const allPacks = discoverSkillPacks()
+  log.header(`Skill Packs ${pc.dim(`(${allPacks.length} available)`)}`)
+  if (config.skillPacks?.length > 0) {
+    for (const packId of config.skillPacks) {
+      const meta = allPacks.find(p => p.id === packId)
+      const desc = meta ? pc.dim(`— ${meta.description.slice(0, 60)}${meta.description.length > 60 ? '…' : ''}`) : ''
+      log.plain(`  ${pc.green('✓')} ${packId} ${desc}`)
+    }
+    const notInstalled = allPacks.filter(p => !config.skillPacks.includes(p.id))
+    if (notInstalled.length > 0) {
+      notInstalled.forEach(p => log.dim(`  · ${p.id}`))
+    }
+  } else {
+    log.dim('  No skill packs installed')
+  }
+
+  // Workflow Packs
+  log.header('Workflow Packs')
+  if (config.workflowPacks?.length > 0) {
+    for (const packId of config.workflowPacks) {
+      const pack = WORKFLOW_PACKS.find(w => w.id === packId)
+      log.plain(`  ${pc.green('✓')} ${pack ? pack.name : packId} ${pc.dim(`— ${pack?.description || ''}`)}`)
+    }
+  } else {
+    log.dim('  No workflow packs installed')
+  }
+
+  // Installed Packages (community/external)
+  const packages = config.packages || {}
+  const packageNames = Object.keys(packages)
+  if (packageNames.length > 0) {
+    log.header(`Packages ${pc.dim(`(${packageNames.length} installed)`)}`)
+    for (const name of packageNames) {
+      const pkg = packages[name]
+      const source = pkg.source || 'unknown'
+      const type = pkg.type || 'unknown'
+      log.plain(`  ${pc.green('✓')} ${pc.bold(name)} ${pc.dim(`v${pkg.version || '?'}`)} ${pc.dim(`— ${type} (${source})`)}`)
+    }
+  }
+
+  // Rules
+  const rulesDir = join(projectRoot, '.ai', 'rules')
+  if (existsSync(rulesDir)) {
+    const ruleFiles = readdirSync(rulesDir).filter(f => f.endsWith('.md')).sort()
+    log.header('Rules')
+
+    if (opts.rules) {
+      // --rules: show each rule with its title
+      for (const file of ruleFiles) {
+        const filePath = join(rulesDir, file)
+        const content = readFileSync(filePath, 'utf8')
+        const firstLine = content.split('\n').find(l => l.startsWith('# '))
+        const title = firstLine ? firstLine.replace(/^#\s+/, '') : '(no title)'
+        log.plain(`  ${pc.dim(file.padEnd(30))} ${title}`)
+      }
+    } else {
+      log.plain(`  ${ruleFiles.length} rule file(s) in .ai/rules/`)
+      ruleFiles.forEach(f => log.verbose(`    ${f}`))
+    }
+  }
+
+  log.plain('')
+}