autodoc-agent-kit 1.0.0

package/tools/cli/commands/install.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { UI } = require('../lib/ui');
+const { Installer } = require('../installers/lib/core/installer');
+
+const ui = new UI();
+const installer = new Installer();
+
+module.exports = {
+  command: 'install',
+  description: 'Install autodoc-agent-kit skills into your project',
+  options: [
+    ['--directory <path>', 'Target project directory (default: current directory)'],
+    ['--modules <modules>', 'Comma-separated module codes to install (e.g. "engineering,qa")'],
+    ['--ides <ides>', 'Comma-separated IDE codes to configure (e.g. "claude-code,cursor")'],
+    ['--global', 'Install skills globally (~/.{ide}/skills) instead of into the current project'],
+    ['-y, --yes', 'Accept all defaults, skip prompts'],
+  ],
+  action: async (options) => {
+    try {
+      const config = await ui.promptInstall(options);
+
+      if (config.cancelled) {
+        console.log('\nInstallation cancelled.\n');
+        process.exit(0);
+      }
+
+      await installer.install(config);
+      process.exit(0);
+    } catch (error) {
+      console.error(`\nInstallation failed: ${error.message}\n`);
+      if (process.env.DEBUG) console.error(error.stack);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/status.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { intro, outro, log } = require('@clack/prompts');
+
+module.exports = {
+  command: 'status',
+  description: 'Show installed autodoc-agent-kit modules and IDEs',
+  options: [['--directory <path>', 'Target project directory (default: current directory)']],
+  action: async (options) => {
+    intro('autodoc-agent-kit status');
+
+    const targetDir = path.resolve(options.directory || process.cwd());
+    const manifestPath = path.join(targetDir, '.autodoc', 'manifest.yaml');
+
+    if (!fs.existsSync(manifestPath)) {
+      log.warn('No .autodoc/manifest.yaml found — nothing installed yet.');
+      log.info('Run: npx autodoc-agent-kit install');
+      outro('Done.');
+      return;
+    }
+
+    const manifest = yaml.load(fs.readFileSync(manifestPath, 'utf8'));
+
+    log.info(`Version:    ${manifest.version}`);
+    log.info(`Installed:  ${manifest.installed_at}`);
+    log.info(`Modules:    ${manifest.modules.join(', ')}`);
+    log.info(`IDEs:       ${manifest.ides.join(', ')}`);
+    log.info(`Skills:     ${manifest.skills_installed.length} total`);
+
+    outro('Done.');
+  },
+};

package/tools/cli/commands/uninstall.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { intro, outro, confirm, log } = require('@clack/prompts');
+
+module.exports = {
+  command: 'uninstall',
+  description: 'Remove autodoc-agent-kit skills from your project',
+  options: [
+    ['--directory <path>', 'Target project directory (default: current directory)'],
+    ['-y, --yes', 'Skip confirmation prompt'],
+  ],
+  action: async (options) => {
+    intro('autodoc-agent-kit uninstall');
+
+    const targetDir = path.resolve(options.directory || process.cwd());
+    const manifestPath = path.join(targetDir, '.autodoc', 'manifest.yaml');
+
+    if (!fs.existsSync(manifestPath)) {
+      log.warn('No .autodoc/manifest.yaml found — nothing to uninstall.');
+      outro('Done.');
+      return;
+    }
+
+    const manifest = yaml.load(fs.readFileSync(manifestPath, 'utf8'));
+
+    log.info(`Found installation: modules [${manifest.modules.join(', ')}] for IDEs [${manifest.ides.join(', ')}]`);
+
+    if (!options.yes) {
+      const confirmed = await confirm({ message: 'Remove all installed skills?' });
+      if (!confirmed) {
+        outro('Cancelled.');
+        process.exit(0);
+      }
+    }
+
+    // Remove skill directories from each configured IDE
+    const { IdeManager } = require('../installers/lib/ide/manager');
+    const ideManager = new IdeManager();
+
+    for (const ideCode of manifest.ides) {
+      const platform = ideManager.getPlatform(ideCode);
+      if (!platform) continue;
+
+      for (const skillName of manifest.skills_installed) {
+        const skillDir = path.join(targetDir, platform.installer.target_dir, skillName);
+        if (fs.existsSync(skillDir)) {
+          fs.removeSync(skillDir);
+          log.info(`Removed ${platform.installer.target_dir}/${skillName}`);
+        }
+      }
+    }
+
+    // Remove manifest
+    fs.removeSync(path.join(targetDir, '.autodoc'));
+    outro('Uninstall complete.');
+  },
+};

package/tools/cli/installers/lib/core/installer.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const os = require('node:os');
+const chalk = require('chalk');
+const cliProgress = require('cli-progress');
+const { spinner, log, outro } = require('@clack/prompts');
+const { ModuleManager } = require('../modules/manager');
+const { IdeManager } = require('../ide/manager');
+const { Manifest } = require('./manifest');
+
+class Installer {
+  constructor() {
+    this.moduleManager = new ModuleManager();
+    this.ideManager = new IdeManager();
+  }
+
+  /**
+   * Main install orchestrator.
+   *
+   * @param {object} config - From UI.promptInstall()
+   * @param {string} config.targetDir - Project root (ignored for global scope)
+   * @param {string[]} config.modules
+   * @param {string[]} config.ides
+   * @param {boolean} config.isReinstall
+   * @param {'project'|'global'} config.scope
+   */
+  async install(config) {
+    const { targetDir, modules, ides, isReinstall, scope = 'project' } = config;
+    // Global installs store their manifest in ~/.autodoc/
+    const manifestBaseDir = scope === 'global' ? os.homedir() : targetDir;
+    const manifest = new Manifest(manifestBaseDir);
+
+    // ── 1. Resolve all skill source paths ───────────────────────────────────
+    const s1 = spinner();
+    s1.start('Resolving skills from selected modules...');
+
+    let skills;
+    try {
+      skills = this.moduleManager.resolveSkills(modules);
+      s1.stop(`Found ${skills.length} skills across ${modules.length} module(s)`);
+    } catch (error) {
+      s1.stop(`Failed: ${error.message}`);
+      throw error;
+    }
+
+    const skillSrcPaths = skills.map((s) => s.srcPath);
+    const skillNames = skills.map((s) => s.skillName);
+
+    // ── 2. Install skills for each selected IDE with progress bars ──────────
+    console.log();
+
+    const multiBar = new cliProgress.MultiBar(
+      {
+        format: ' {bar} {percentage}% │ {ideName} │ {value}/{total} skills │ {skillName}',
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        clearOnComplete: false,
+        stopOnComplete: false,
+        barsize: 30,
+        linewrap: false,
+        forceRedraw: true,
+      },
+      cliProgress.Presets.shades_classic
+    );
+
+    // Create a bar for each IDE, using setTotal to override the default
+    const bars = [];
+    for (const ideCode of ides) {
+      const platform = this.ideManager.getPlatform(ideCode);
+      if (!platform) {
+        log.warn(`Unknown IDE code "${ideCode}" — skipping`);
+        continue;
+      }
+      const bar = multiBar.create(skills.length, 0, {
+        ideName: platform.name.padEnd(20),
+        skillName: chalk.dim('waiting...'),
+      });
+      bar.setTotal(skills.length);
+      bars.push({ ideCode, platform, bar });
+    }
+
+    // Install skills sequentially per IDE, updating each bar per-skill
+    const results = [];
+    for (const { ideCode, platform, bar } of bars) {
+      try {
+        const installed = await this.ideManager.installSkills(
+          targetDir,
+          ideCode,
+          skillSrcPaths,
+          isReinstall,
+          scope,
+          (skillName) => {
+            bar.increment(1, {
+              ideName: platform.name.padEnd(20),
+              skillName,
+            });
+          }
+        );
+
+        const resolvedDir = this.ideManager.resolveInstallDir(
+          targetDir,
+          platform.installer,
+          scope
+        );
+
+        bar.update(skills.length, {
+          ideName: platform.name.padEnd(20),
+          skillName: chalk.green('\u2714 done'),
+        });
+
+        results.push({ ideCode, platform, installed, resolvedDir });
+      } catch (error) {
+        bar.update(bar.value, {
+          ideName: platform.name.padEnd(20),
+          skillName: chalk.red('\u2716 failed'),
+        });
+        results.push({ ideCode, platform, error });
+      }
+    }
+
+    multiBar.stop();
+    console.log();
+
+    // ── 3. Post-install summary per IDE ─────────────────────────────────────
+    for (const result of results) {
+      if (result.error) {
+        log.warn(`${result.platform.name}: failed — ${result.error.message}`);
+      } else {
+        log.success(`${result.platform.name}: ${result.installed.length} skills → ${result.resolvedDir}/`);
+      }
+    }
+
+    // ── 4. Write manifest ────────────────────────────────────────────────────
+    manifest.write({ modules, ides, skills_installed: skillNames, scope });
+
+    // ── 5. Summary ───────────────────────────────────────────────────────────
+    const totalInstalls = results.reduce((sum, r) => sum + (r.installed ? r.installed.length : 0), 0);
+    const successIdes = results.filter((r) => !r.error).length;
+
+    console.log();
+    log.info(chalk.dim('─'.repeat(50)));
+    log.success(
+      `${chalk.bold(totalInstalls)} skills installed across ${chalk.bold(successIdes)} IDE(s)`
+    );
+    log.info(`Manifest saved to .autodoc/manifest.yaml`);
+    log.info(chalk.dim('─'.repeat(50)));
+
+    if (isReinstall) {
+      log.info('Modified skills were backed up with a .bak suffix before reinstalling');
+    }
+
+    const moduleLabels = modules
+      .map((code) => {
+        const def = this.moduleManager.getModuleDef(code);
+        return def ? def.name : code;
+      })
+      .join(', ');
+
+    outro(`Done! Modules installed: ${moduleLabels}`);
+  }
+}
+
+module.exports = { Installer };

package/tools/cli/installers/lib/core/manifest.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+const packageJson = require('../../../../../package.json');
+
+class Manifest {
+  constructor(targetDir) {
+    this.targetDir = targetDir;
+    this.autodocDir = path.join(targetDir, '.autodoc');
+    this.manifestPath = path.join(this.autodocDir, 'manifest.yaml');
+  }
+
+  /**
+   * Writes the .autodoc/manifest.yaml tracking file.
+   *
+   * @param {object} data
+   * @param {string[]} data.modules - Installed module codes
+   * @param {string[]} data.ides - Installed IDE codes
+   * @param {string[]} data.skills_installed - All installed skill names
+   * @param {'project'|'global'} data.scope - Install scope
+   */
+  write({ modules, ides, skills_installed, scope = 'project' }) {
+    fs.ensureDirSync(this.autodocDir);
+
+    const manifest = {
+      version: packageJson.version,
+      installed_at: new Date().toISOString(),
+      scope,
+      modules,
+      ides,
+      skills_installed,
+    };
+
+    fs.writeFileSync(this.manifestPath, yaml.dump(manifest, { lineWidth: 120 }), 'utf8');
+  }
+
+  /**
+   * Reads and returns the existing manifest, or null if not present.
+   */
+  read() {
+    if (!fs.existsSync(this.manifestPath)) return null;
+    return yaml.load(fs.readFileSync(this.manifestPath, 'utf8'));
+  }
+}
+
+module.exports = { Manifest };

package/tools/cli/installers/lib/ide/manager.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+const PLATFORM_CODES_PATH = path.join(__dirname, 'platform-codes.yaml');
+
+class IdeManager {
+  constructor() {
+    this._platforms = null;
+  }
+
+  /**
+   * Lazily loads and caches platform-codes.yaml
+   */
+  get platforms() {
+    if (!this._platforms) {
+      const raw = yaml.load(fs.readFileSync(PLATFORM_CODES_PATH, 'utf8'));
+      this._platforms = raw.platforms;
+    }
+    return this._platforms;
+  }
+
+  /**
+   * Returns a single platform definition by code, or null.
+   */
+  getPlatform(code) {
+    return this.platforms[code] || null;
+  }
+
+  /**
+   * Resolves the absolute install directory for an IDE given a scope.
+   *
+   * @param {string} projectDir - Absolute path to the user's project root
+   * @param {object} installer - The installer config from platform-codes.yaml
+   * @param {'project'|'global'} scope
+   * @returns {string} Absolute path where skills will be written
+   */
+  resolveInstallDir(projectDir, installer, scope) {
+    if (scope === 'global') {
+      if (!installer.global_dir) {
+        throw new Error('This platform does not define a global_dir');
+      }
+      return path.join(os.homedir(), installer.global_dir);
+    }
+    return path.join(projectDir, installer.target_dir);
+  }
+
+  /**
+   * Installs a list of skill source directories into a target IDE directory.
+   * Each skill is a directory containing SKILL.md (and optional sub-dirs).
+   *
+   * @param {string} projectDir - Root of the user's project
+   * @param {string} ideCode - Platform code (e.g. "claude-code")
+   * @param {string[]} skillSrcPaths - Absolute paths to skill source directories
+   * @param {boolean} isReinstall - Whether to back up before overwriting
+   * @param {'project'|'global'} scope - Install scope
+   * @param {function} [onSkillInstalled] - Optional callback(skillName) called after each skill is copied
+   * @returns {string[]} List of installed skill names
+   */
+  async installSkills(projectDir, ideCode, skillSrcPaths, isReinstall = false, scope = 'project', onSkillInstalled) {
+    const platform = this.getPlatform(ideCode);
+    if (!platform || !platform.installer) {
+      throw new Error(`Unknown or unsupported IDE: ${ideCode}`);
+    }
+
+    const { legacy_targets } = platform.installer;
+    const ideTargetDir = this.resolveInstallDir(projectDir, platform.installer, scope);
+
+    // Clean up legacy directories if they exist (project-scope only)
+    if (scope === 'project' && legacy_targets) {
+      for (const legacy of legacy_targets) {
+        const legacyPath = path.join(projectDir, legacy);
+        if (fs.existsSync(legacyPath)) {
+          fs.removeSync(legacyPath);
+        }
+      }
+    }
+
+    fs.ensureDirSync(ideTargetDir);
+
+    const installed = [];
+
+    for (const skillSrc of skillSrcPaths) {
+      const skillName = path.basename(skillSrc);
+      const skillDest = path.join(ideTargetDir, skillName);
+
+      // Backup existing skill directory if reinstalling and it already exists
+      if (isReinstall && fs.existsSync(skillDest)) {
+        const backupPath = `${skillDest}.bak`;
+        fs.removeSync(backupPath);
+        fs.copySync(skillDest, backupPath);
+      }
+
+      // Copy skill directory recursively
+      fs.copySync(skillSrc, skillDest, { overwrite: true });
+      installed.push(skillName);
+
+      if (onSkillInstalled) {
+        onSkillInstalled(skillName);
+        // Small delay so the user can see each skill being installed
+        await new Promise((resolve) => setTimeout(resolve, 15));
+      }
+    }
+
+    return installed;
+  }
+}
+
+module.exports = { IdeManager };

package/tools/cli/installers/lib/ide/platform-codes.yaml

@@ -0,0 +1,207 @@
+# autodoc-agent-kit Platform Codes
+# Defines all supported AI IDEs and their skill installation targets.
+# Each platform uses skill_format: true — skills are installed as {skill-name}/SKILL.md directories.
+#
+# target_dir  — relative to the project root (project-scoped install)
+# global_dir  — relative to $HOME (global install, available in all projects)
+
+platforms:
+  antigravity:
+    name: "Google Antigravity"
+    preferred: true
+    category: ide
+    description: "Google's AI development environment"
+    installer:
+      legacy_targets:
+        - .agent/workflows
+      target_dir: .agent/skills
+      global_dir: .gemini/antigravity/skills
+      template_type: default
+      skill_format: true
+
+  auggie:
+    name: "Auggie"
+    preferred: false
+    category: cli
+    description: "AI development tool"
+    installer:
+      legacy_targets:
+        - .augment/commands
+      target_dir: .augment/skills
+      global_dir: .augment/skills
+      template_type: default
+      skill_format: true
+
+  claude-code:
+    name: "Claude Code"
+    preferred: true
+    category: cli
+    description: "Anthropic's official CLI for Claude"
+    installer:
+      legacy_targets:
+        - .claude/commands
+      target_dir: .claude/skills
+      global_dir: .claude/skills
+      template_type: default
+      skill_format: true
+      ancestor_conflict_check: true
+
+  cline:
+    name: "Cline"
+    preferred: false
+    category: ide
+    description: "AI coding assistant"
+    installer:
+      legacy_targets:
+        - .clinerules/workflows
+      target_dir: .cline/skills
+      global_dir: .cline/skills
+      template_type: default
+      skill_format: true
+
+  codex:
+    name: "Codex"
+    preferred: false
+    category: cli
+    description: "OpenAI Codex integration"
+    installer:
+      legacy_targets:
+        - .codex/prompts
+      target_dir: .codex/skills
+      global_dir: .codex/skills
+      template_type: default
+      skill_format: true
+
+  codebuddy:
+    name: "CodeBuddy"
+    preferred: false
+    category: ide
+    description: "Tencent Cloud Code Assistant"
+    installer:
+      legacy_targets:
+        - .codebuddy/commands
+      target_dir: .codebuddy/skills
+      global_dir: .codebuddy/skills
+      template_type: default
+      skill_format: true
+
+  cursor:
+    name: "Cursor"
+    preferred: true
+    category: ide
+    description: "AI-first code editor"
+    installer:
+      legacy_targets:
+        - .cursor/commands
+      target_dir: .cursor/skills
+      global_dir: .cursor/skills
+      template_type: default
+      skill_format: true
+
+  gemini:
+    name: "Gemini CLI"
+    preferred: false
+    category: cli
+    description: "Google's CLI for Gemini"
+    installer:
+      legacy_targets:
+        - .gemini/commands
+      target_dir: .gemini/skills
+      global_dir: .gemini/skills
+      template_type: default
+      skill_format: true
+
+  github-copilot:
+    name: "GitHub Copilot"
+    preferred: false
+    category: ide
+    description: "GitHub's AI pair programmer"
+    installer:
+      legacy_targets:
+        - .github/agents
+        - .github/prompts
+      target_dir: .github/skills
+      global_dir: .github/skills
+      template_type: default
+      skill_format: true
+
+  kiro:
+    name: "Kiro"
+    preferred: false
+    category: ide
+    description: "Amazon's AI-powered IDE"
+    installer:
+      legacy_targets:
+        - .kiro/steering
+      target_dir: .kiro/skills
+      global_dir: .kiro/skills
+      template_type: default
+      skill_format: true
+
+  opencode:
+    name: "OpenCode"
+    preferred: false
+    category: ide
+    description: "OpenCode terminal coding assistant"
+    installer:
+      legacy_targets:
+        - .opencode/agents
+        - .opencode/commands
+      target_dir: .opencode/skill
+      global_dir: .config/opencode/skill
+      template_type: default
+      skill_format: true
+
+  pi:
+    name: "Pi"
+    preferred: false
+    category: cli
+    description: "Provider-agnostic terminal-native AI coding agent"
+    installer:
+      target_dir: .pi/skills
+      global_dir: .pi/skills
+      template_type: default
+      skill_format: true
+
+  roo:
+    name: "Roo Code"
+    preferred: false
+    category: ide
+    description: "Enhanced Cline fork"
+    installer:
+      legacy_targets:
+        - .roo/commands
+      target_dir: .roo/skills
+      global_dir: .roo/skills
+      template_type: default
+      skill_format: true
+
+  windsurf:
+    name: "Windsurf"
+    preferred: false
+    category: ide
+    description: "AI-powered IDE with cascade flows"
+    installer:
+      legacy_targets:
+        - .windsurf/workflows
+      target_dir: .windsurf/skills
+      global_dir: .codeium/windsurf/skills
+      template_type: default
+      skill_format: true
+
+  zed:
+    name: "Zed"
+    preferred: false
+    category: ide
+    description: "High-performance multiplayer code editor"
+    installer:
+      target_dir: .zed/skills
+      global_dir: .config/zed/skills
+      template_type: default
+      skill_format: true
+
+categories:
+  ide:
+    name: "Integrated Development Environment"
+  cli:
+    name: "Command Line Interface"