@siliconoid/agentkit 0.1.0

package/lib/commands/remove.mjs

@@ -0,0 +1,126 @@
+import { join } from 'path'
+import { existsSync, rmSync, readdirSync } from 'fs'
+import { findProjectRoot, readConfig, writeConfig } from '../utils.mjs'
+import { runSync } from './sync.mjs'
+import log from '../log.mjs'
+import pc from 'picocolors'
+
+/**
+ * Remove an installed package (rules, skills, skill-packs).
+ * @param {string} packageName - Name of the package to remove
+ * @param {object} opts - Command options
+ */
+export async function runRemove(packageName, 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)
+    }
+
+    if (!config.packages || !config.packages[packageName]) {
+      log.error(`Package "${packageName}" is not installed.`)
+      log.plain('')
+
+      // Show installed packages
+      const installed = Object.keys(config.packages || {})
+      if (installed.length > 0) {
+        log.plain('Installed packages:')
+        installed.forEach(name => {
+          const pkg = config.packages[name]
+          log.plain(`  ${pc.dim('·')} ${name} ${pc.dim(`(${pkg.type}, ${pkg.source})`)}`)
+        })
+      } else {
+        log.plain('No packages installed. Use `agentkit install <source>` to install.')
+      }
+      log.plain('')
+      process.exit(1)
+    }
+
+    const pkg = config.packages[packageName]
+    log.info(`\nRemoving package: ${pc.bold(packageName)}\n`)
+    log.plain(`  Type:     ${pkg.type}`)
+    log.plain(`  Source:   ${pkg.source}`)
+    log.plain(`  Files:    ${pkg.files?.length || 0}`)
+    log.plain('')
+
+    let removedCount = 0
+
+    // Remove installed files
+    if (pkg.files && pkg.files.length > 0) {
+      log.header('Removing files...')
+      for (const file of pkg.files) {
+        const fullPath = join(projectRoot, '.ai', file)
+        if (existsSync(fullPath)) {
+          rmSync(fullPath, { recursive: true, force: true })
+          log.removed(file)
+          removedCount++
+        } else {
+          log.verbose(`  Already removed: ${file}`)
+        }
+      }
+    }
+
+    // Also remove from platform skill directories
+    const platformSkillDirs = {
+      claude: '.claude/skills',
+      codex: '.codex/skills',
+      gemini: '.gemini/skills',
+      antigravity: '.agent/skills',
+    }
+
+    // Check if any skills were installed and clean up platform copies
+    const skillFiles = (pkg.files || []).filter(f => f.startsWith('skills/'))
+    if (skillFiles.length > 0) {
+      log.header('Cleaning platform copies...')
+      for (const platformId of config.platforms || []) {
+        const baseDir = platformSkillDirs[platformId]
+        if (!baseDir) continue
+
+        for (const skillFile of skillFiles) {
+          // skillFile is like "skills/my-skill/"
+          const skillName = skillFile.replace('skills/', '').replace(/\/$/, '')
+          const platformSkillPath = join(projectRoot, baseDir, skillName)
+          if (existsSync(platformSkillPath)) {
+            rmSync(platformSkillPath, { recursive: true, force: true })
+            log.removed(`${baseDir}/${skillName}`)
+            removedCount++
+          }
+        }
+      }
+    }
+
+    // Unregister from config
+    delete config.packages[packageName]
+    writeConfig(projectRoot, config)
+
+    // Re-sync platforms
+    log.header('Re-syncing platforms...')
+    await runSync({ _projectRoot: projectRoot, _platforms: config.platforms })
+
+    log.summary(`Package "${packageName}" removed successfully!`, [
+      `Removed ${removedCount} file(s)/dir(s)`,
+      '',
+      'Run `agentkit list` to see remaining packages.',
+    ])
+  } catch (err) {
+    log.error(`Remove failed: ${err.message}`)
+    log.verbose(err.stack)
+    process.exit(1)
+  }
+}
+
+/**
+ * List all installed packages.
+ */
+export function listPackages(projectRoot) {
+  const config = readConfig(projectRoot)
+  if (!config || !config.packages) return []
+
+  return Object.entries(config.packages).map(([name, pkg]) => ({
+    name,
+    ...pkg,
+  }))
+}

package/lib/commands/sync.mjs

@@ -0,0 +1,155 @@
+import { join } from 'path'
+import { existsSync, rmSync, readdirSync, readFileSync } from 'fs'
+import {
+  findProjectRoot, readConfig, discoverSkills,
+  writeWithMarker, ensureDir, MARKERS,
+} from '../utils.mjs'
+import log from '../log.mjs'
+
+/**
+ * Remove auto-generated files (those starting with marker) from platform dirs.
+ */
+function cleanGenerated(projectRoot, platforms) {
+  const removed = []
+
+  for (const platformId of platforms) {
+    const dirsToClean = []
+
+    switch (platformId) {
+      case 'claude':
+        dirsToClean.push(join(projectRoot, '.claude', 'skills'))
+        break
+      case 'codex':
+        dirsToClean.push(join(projectRoot, '.codex', 'skills'))
+        break
+      case 'gemini':
+        dirsToClean.push(join(projectRoot, '.gemini', 'skills'))
+        break
+      case 'antigravity':
+        dirsToClean.push(join(projectRoot, '.agent', 'skills'))
+        break
+    }
+
+    for (const dir of dirsToClean) {
+      if (!existsSync(dir)) continue
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue
+        const stubPath = join(dir, entry.name, 'SKILL.md')
+        if (!existsSync(stubPath)) continue
+        const content = readFileSync(stubPath, 'utf8')
+        if (content.startsWith(MARKERS.md)) {
+          rmSync(join(dir, entry.name), { recursive: true })
+          removed.push(`${platformId}: ${entry.name}/`)
+        }
+      }
+    }
+  }
+
+  return removed
+}
+
+export async function runSync(opts = {}) {
+  try {
+    const projectRoot = opts._projectRoot || findProjectRoot()
+    const config = opts._platforms
+      ? { platforms: opts._platforms }
+      : readConfig(projectRoot)
+
+    if (!config) {
+      log.error('No .ai/agentkit.json found. Run `agentkit init` first.')
+      process.exit(1)
+    }
+
+    const vars = opts._vars || {
+      projectName: config.projectName || 'project',
+      projectDescription: config.projectDescription || '',
+    }
+
+    // Handle --clean: remove auto-generated files first
+    if (opts.clean) {
+      const removed = cleanGenerated(projectRoot, config.platforms)
+      if (removed.length > 0) {
+        log.info(`Cleaned ${removed.length} auto-generated file(s):`)
+        removed.forEach(r => log.removed(r))
+        log.plain('')
+      }
+    }
+
+    const skills = discoverSkills(projectRoot)
+    if (skills.length === 0) {
+      log.warn('No skills found in .ai/skills/. Nothing to sync.')
+      return
+    }
+
+    log.info(`Found ${skills.length} skill(s): ${skills.map(s => s.name).join(', ')}`)
+
+    const results = {}
+
+    for (const platformId of config.platforms) {
+      const adapter = await import(`../adapters/${platformId}.mjs`)
+      const paths = adapter.getOutputPaths(projectRoot)
+      results[platformId] = []
+
+      for (const skill of skills) {
+        // Generate skill stub
+        if (adapter.generateSkillStub && paths.skillsDir) {
+          const stub = adapter.generateSkillStub(skill.manifest, vars)
+          if (stub) {
+            const skillDir = join(paths.skillsDir, skill.name)
+            ensureDir(skillDir)
+            const stubPath = join(skillDir, 'SKILL.md')
+            const marker = adapter.marker || MARKERS.md
+            if (!opts.dry) {
+              writeWithMarker(stubPath, stub, marker)
+            }
+            results[platformId].push(`skill: ${skill.name}`)
+          }
+        }
+
+        // Generate command
+        if (adapter.generateCommand && paths.commandsDir) {
+          const cmd = adapter.generateCommand(skill.manifest)
+          if (cmd) {
+            ensureDir(paths.commandsDir)
+            const ext = platformId === 'gemini' ? '.toml' : '.md'
+            const cmdPath = join(paths.commandsDir, `${skill.name}${ext}`)
+            const marker = platformId === 'gemini'
+              ? (adapter.commandMarker || MARKERS.toml)
+              : (adapter.marker || MARKERS.md)
+            if (!opts.dry) {
+              writeWithMarker(cmdPath, cmd, marker)
+            }
+            results[platformId].push(`command: ${skill.name}`)
+          }
+        }
+      }
+    }
+
+    // Handle Windsurf merged rules
+    if (config.platforms.includes('windsurf')) {
+      const adapter = await import('../adapters/windsurf.mjs')
+      const paths = adapter.getOutputPaths(projectRoot)
+      const content = adapter.generateMergedRules(projectRoot, vars)
+      if (!opts.dry) {
+        writeWithMarker(paths.rootDoc, content, adapter.marker)
+      }
+      results.windsurf = results.windsurf || []
+      results.windsurf.push('merged .windsurfrules')
+    }
+
+    // Summary
+    const prefix = opts.dry ? '[DRY RUN] Would generate' : 'Generated'
+    log.header(`${prefix}:`)
+    for (const [platform, items] of Object.entries(results)) {
+      if (items.length > 0) {
+        log.info(`  ${platform}: ${items.length} file(s)`)
+        items.forEach(i => log.verbose(`    - ${i}`))
+      }
+    }
+    log.plain('')
+  } catch (err) {
+    log.error(`Sync failed: ${err.message}`)
+    log.verbose(err.stack)
+    process.exit(1)
+  }
+}

package/lib/commands/update.mjs

@@ -0,0 +1,113 @@
+import { join, relative } from 'path'
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs'
+import {
+  findProjectRoot, readConfig, getTemplatesDir, ensureDir, templateReplace,
+} from '../utils.mjs'
+import { scaffoldWorkflows, scaffoldSkills, scaffoldPlatforms } from '../scaffold.mjs'
+import log from '../log.mjs'
+
+export async function runUpdate(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)
+    }
+
+    const vars = {
+      projectName: config.projectName || 'project',
+      projectDescription: config.projectDescription || '',
+      framework: config.framework || 'custom',
+    }
+
+    const templatesDir = getTemplatesDir()
+    const updated = []
+    const skipped = []
+
+    log.info('Checking for template updates...\n')
+
+    function processDir(templateDir, targetDir) {
+      if (!existsSync(templateDir)) return
+
+      for (const entry of readdirSync(templateDir, { withFileTypes: true })) {
+        const srcPath = join(templateDir, entry.name)
+        const destPath = join(targetDir, entry.name)
+
+        if (entry.isDirectory()) {
+          processDir(srcPath, destPath)
+          continue
+        }
+
+        const templateContent = templateReplace(readFileSync(srcPath, 'utf8'), vars)
+
+        if (!existsSync(destPath)) {
+          ensureDir(targetDir)
+          writeFileSync(destPath, templateContent)
+          updated.push(relative(projectRoot, destPath))
+        } else if (opts.force) {
+          writeFileSync(destPath, templateContent)
+          updated.push(relative(projectRoot, destPath))
+        } else {
+          skipped.push(relative(projectRoot, destPath))
+        }
+      }
+    }
+
+    // Update base templates
+    processDir(join(templatesDir, 'base'), projectRoot)
+
+    // Update framework templates
+    if (config.framework && config.framework !== 'custom') {
+      processDir(join(templatesDir, 'frameworks', config.framework), projectRoot)
+    }
+
+    // Ensure platform root docs exist
+    if (config.platforms) {
+      const platFiles = await scaffoldPlatforms(projectRoot, config.platforms, vars)
+      if (platFiles.length > 0) {
+        log.success(`Platform root docs: + ${platFiles.length} new file(s)`)
+        updated.push(...platFiles)
+      }
+    }
+
+    // Update workflow packs (non-destructive: only adds missing files)
+    if (config.workflowPacks?.length > 0 && config.platforms) {
+      const wfFiles = scaffoldWorkflows(projectRoot, config.platforms, config.workflowPacks)
+      if (wfFiles.length > 0) {
+        log.success(`Workflow packs: + ${wfFiles.length} new file(s)`)
+        updated.push(...wfFiles)
+      }
+    }
+
+    // Update skill packs (non-destructive: only adds missing files)
+    if (config.skillPacks?.length > 0 && config.platforms) {
+      const skillFiles = scaffoldSkills(projectRoot, config.platforms, config.skillPacks)
+      if (skillFiles.length > 0) {
+        log.success(`Skill packs: + ${skillFiles.length} new file(s)`)
+        updated.push(...skillFiles)
+      }
+    }
+
+    // Summary
+    if (updated.length > 0) {
+      log.header('Updated files:')
+      updated.forEach(f => log.created(f))
+    }
+
+    if (skipped.length > 0) {
+      log.dim(`\nSkipped ${skipped.length} existing file(s) (use --force to overwrite)`)
+    }
+
+    if (updated.length === 0 && skipped.length === 0) {
+      log.success('\nEverything is up to date.')
+    }
+
+    log.plain('')
+  } catch (err) {
+    log.error(`Update failed: ${err.message}`)
+    log.verbose(err.stack)
+    process.exit(1)
+  }
+}

package/lib/index.mjs

@@ -0,0 +1,233 @@
+/**
+ * Programmatic API for AgentKit.
+ *
+ * Usage:
+ *   import { init, sync, list, doctor, diff, install, remove } from 'agentkit'
+ *
+ *   await init({ smart: true, projectRoot: '/path/to/project' })
+ *   await sync({ projectRoot: '/path/to/project' })
+ */
+
+import { findProjectRoot, readConfig, writeConfig, PLATFORMS, WORKFLOW_PACKS, discoverSkillPacks, discoverSkills } from './utils.mjs'
+import { autoDetect, recommendSkillPacks, frameworkDisplayName } from './prompts.mjs'
+import { setVerbosity } from './log.mjs'
+
+// ---------------------------------------------------------------------------
+// Init
+// ---------------------------------------------------------------------------
+
+/**
+ * Initialize AI project rules.
+ * @param {object} opts
+ * @param {string} [opts.projectRoot] - Project root (default: auto-detect)
+ * @param {boolean} [opts.smart] - Zero-question auto-detected init
+ * @param {boolean} [opts.minimal] - Minimal init
+ * @param {boolean} [opts.yes] - Use defaults without prompting
+ * @param {boolean} [opts.force] - Re-initialize even if configured
+ * @param {boolean} [opts.dryRun] - Preview only
+ * @param {boolean} [opts.quiet] - Suppress output
+ * @returns {Promise<{ success: boolean, config?: object, error?: string }>}
+ */
+export async function init(opts = {}) {
+  if (opts.quiet) setVerbosity(0)
+  try {
+    const { runInit } = await import('./commands/init.mjs')
+    // Pass projectRoot override if provided
+    if (opts.projectRoot) {
+      const origCwd = process.cwd()
+      process.chdir(opts.projectRoot)
+      try {
+        await runInit(opts)
+      } finally {
+        process.chdir(origCwd)
+      }
+    } else {
+      await runInit(opts)
+    }
+    const projectRoot = opts.projectRoot || findProjectRoot()
+    const config = readConfig(projectRoot)
+    return { success: true, config }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Sync
+// ---------------------------------------------------------------------------
+
+/**
+ * Sync skills to all configured platform adapters.
+ * @param {object} opts
+ * @param {string} [opts.projectRoot]
+ * @param {boolean} [opts.clean]
+ * @param {boolean} [opts.dry]
+ * @param {boolean} [opts.quiet]
+ * @returns {Promise<{ success: boolean, error?: string }>}
+ */
+export async function sync(opts = {}) {
+  if (opts.quiet) setVerbosity(0)
+  try {
+    const { runSync } = await import('./commands/sync.mjs')
+    if (opts.projectRoot) {
+      await runSync({ ...opts, _projectRoot: opts.projectRoot })
+    } else {
+      await runSync(opts)
+    }
+    return { success: true }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Doctor
+// ---------------------------------------------------------------------------
+
+/**
+ * Run diagnostics on project configuration.
+ * @param {object} opts
+ * @param {string} [opts.projectRoot]
+ * @param {boolean} [opts.deep]
+ * @param {boolean} [opts.quiet]
+ * @returns {Promise<{ success: boolean, issues?: string[], error?: string }>}
+ */
+export async function doctor(opts = {}) {
+  if (opts.quiet) setVerbosity(0)
+  try {
+    const { runDoctor } = await import('./commands/doctor.mjs')
+    if (opts.projectRoot) {
+      const origCwd = process.cwd()
+      process.chdir(opts.projectRoot)
+      try {
+        await runDoctor(opts)
+      } finally {
+        process.chdir(origCwd)
+      }
+    } else {
+      await runDoctor(opts)
+    }
+    return { success: true }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Install
+// ---------------------------------------------------------------------------
+
+/**
+ * Install a package (rules, skills, skill-packs).
+ * @param {string} source - Local path or npm package name
+ * @param {object} opts
+ * @param {string} [opts.projectRoot]
+ * @param {boolean} [opts.force]
+ * @param {boolean} [opts.quiet]
+ * @returns {Promise<{ success: boolean, error?: string }>}
+ */
+export async function install(source, opts = {}) {
+  if (opts.quiet) setVerbosity(0)
+  try {
+    const { runInstall } = await import('./commands/install.mjs')
+    if (opts.projectRoot) {
+      const origCwd = process.cwd()
+      process.chdir(opts.projectRoot)
+      try {
+        await runInstall(source, opts)
+      } finally {
+        process.chdir(origCwd)
+      }
+    } else {
+      await runInstall(source, opts)
+    }
+    return { success: true }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Remove
+// ---------------------------------------------------------------------------
+
+/**
+ * Remove an installed package.
+ * @param {string} packageName
+ * @param {object} opts
+ * @param {string} [opts.projectRoot]
+ * @param {boolean} [opts.quiet]
+ * @returns {Promise<{ success: boolean, error?: string }>}
+ */
+export async function remove(packageName, opts = {}) {
+  if (opts.quiet) setVerbosity(0)
+  try {
+    const { runRemove } = await import('./commands/remove.mjs')
+    if (opts.projectRoot) {
+      const origCwd = process.cwd()
+      process.chdir(opts.projectRoot)
+      try {
+        await runRemove(packageName, opts)
+      } finally {
+        process.chdir(origCwd)
+      }
+    } else {
+      await runRemove(packageName, opts)
+    }
+    return { success: true }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Detection & Info (synchronous)
+// ---------------------------------------------------------------------------
+
+/**
+ * Auto-detect project configuration.
+ * @param {string} [projectRoot]
+ * @returns {object} Detected project info
+ */
+export function detect(projectRoot) {
+  const root = projectRoot || findProjectRoot()
+  return autoDetect(root)
+}
+
+/**
+ * Get current project config.
+ * @param {string} [projectRoot]
+ * @returns {object|null}
+ */
+export function getConfig(projectRoot) {
+  const root = projectRoot || findProjectRoot()
+  return readConfig(root)
+}
+
+/**
+ * List available skill packs.
+ * @returns {Array<{id: string, name: string, description: string}>}
+ */
+export function getAvailableSkillPacks() {
+  return discoverSkillPacks()
+}
+
+/**
+ * List available platforms.
+ * @returns {Array<{id: string, name: string, rootFile: string}>}
+ */
+export function getAvailablePlatforms() {
+  return [...PLATFORMS]
+}
+
+/**
+ * List available workflow packs.
+ * @returns {Array}
+ */
+export function getAvailableWorkflowPacks() {
+  return [...WORKFLOW_PACKS]
+}
+
+// Re-export useful utilities
+export { autoDetect, recommendSkillPacks, frameworkDisplayName }
+export { PLATFORMS, WORKFLOW_PACKS }