@brainfish-ai/devdoc 0.1.26 → 0.1.28

package/dist/cli/commands/ai.d.ts

@@ -0,0 +1,6 @@
+type AITool = 'claude' | 'cursor' | 'both';
+interface AIOptions {
+    tool?: AITool;
+}
+export declare function ai(options: AIOptions): Promise<void>;
+export {};

package/dist/cli/commands/ai.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ai = ai;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const logger_1 = require("../../utils/logger");
+// Simple prompt helper using readline
+async function prompt(question, defaultValue) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const displayQuestion = defaultValue
+            ? `${question} (${defaultValue}): `
+            : `${question}: `;
+        rl.question(displayQuestion, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+async function promptSelect(question, choices) {
+    console.log(`\n${question}\n`);
+    choices.forEach((choice, i) => {
+        console.log(`  ${i + 1}. ${choice.label}`);
+    });
+    console.log();
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('Enter number: ', (answer) => {
+            rl.close();
+            const index = parseInt(answer.trim(), 10) - 1;
+            if (index >= 0 && index < choices.length) {
+                resolve(choices[index].value);
+            }
+            else {
+                // Default to first choice
+                resolve(choices[0].value);
+            }
+        });
+    });
+}
+// Claude Code skills to create
+const CLAUDE_SKILLS = [
+    'bootstrap-docs',
+    'migrate-docs',
+    'import-api-spec',
+    'sync-docs',
+    'check-docs',
+    'create-doc-page',
+    'update-docs-json',
+    'generate-api-docs',
+    'docs-from-code',
+];
+// Cursor rules to create
+const CURSOR_RULES = [
+    'devdoc.mdc',
+    'devdoc-bootstrap.mdc',
+    'devdoc-migrate.mdc',
+    'devdoc-sync.mdc',
+];
+/**
+ * Get the template directory path (handles both development and installed package scenarios)
+ */
+function getTemplateDir() {
+    // Try relative to this file (packages/devdoc/src/cli/commands -> packages/devdoc/templates)
+    let templateDir = path_1.default.join(__dirname, '..', '..', '..', 'templates', 'starter');
+    if (fs_extra_1.default.existsSync(templateDir)) {
+        return templateDir;
+    }
+    // Try devdoc/templates at repo root (development - monorepo structure)
+    // __dirname is packages/devdoc/src/cli/commands -> go up 5 levels to repo root
+    templateDir = path_1.default.join(__dirname, '..', '..', '..', '..', '..', 'devdoc', 'templates', 'starter');
+    if (fs_extra_1.default.existsSync(templateDir)) {
+        return templateDir;
+    }
+    // Try node_modules location (installed package)
+    templateDir = path_1.default.join(__dirname, '..', '..', 'templates', 'starter');
+    if (fs_extra_1.default.existsSync(templateDir)) {
+        return templateDir;
+    }
+    throw new Error('Could not find template directory');
+}
+/**
+ * Copy CLAUDE.md to project root
+ */
+function copyClaudeMd(projectPath, templateDir) {
+    const sourcePath = path_1.default.join(templateDir, 'CLAUDE.md');
+    const destPath = path_1.default.join(projectPath, 'CLAUDE.md');
+    if (!fs_extra_1.default.existsSync(sourcePath)) {
+        logger_1.logger.warn('CLAUDE.md template not found');
+        return false;
+    }
+    fs_extra_1.default.copySync(sourcePath, destPath);
+    return true;
+}
+/**
+ * Copy Claude Code skills to .claude/skills/
+ */
+function copyClaudeSkills(projectPath, templateDir) {
+    const copied = [];
+    const sourceSkillsDir = path_1.default.join(templateDir, '.claude', 'skills');
+    const destSkillsDir = path_1.default.join(projectPath, '.claude', 'skills');
+    if (!fs_extra_1.default.existsSync(sourceSkillsDir)) {
+        logger_1.logger.warn('Claude skills template directory not found');
+        return copied;
+    }
+    // Ensure destination directory exists
+    fs_extra_1.default.ensureDirSync(destSkillsDir);
+    for (const skill of CLAUDE_SKILLS) {
+        const sourceDir = path_1.default.join(sourceSkillsDir, skill);
+        const destDir = path_1.default.join(destSkillsDir, skill);
+        if (fs_extra_1.default.existsSync(sourceDir)) {
+            fs_extra_1.default.copySync(sourceDir, destDir);
+            copied.push(skill);
+        }
+    }
+    return copied;
+}
+/**
+ * Copy Cursor rules to .cursor/rules/
+ */
+function copyCursorRules(projectPath, templateDir) {
+    const copied = [];
+    const sourceRulesDir = path_1.default.join(templateDir, '.cursor', 'rules');
+    const destRulesDir = path_1.default.join(projectPath, '.cursor', 'rules');
+    if (!fs_extra_1.default.existsSync(sourceRulesDir)) {
+        logger_1.logger.warn('Cursor rules template directory not found');
+        return copied;
+    }
+    // Ensure destination directory exists
+    fs_extra_1.default.ensureDirSync(destRulesDir);
+    for (const rule of CURSOR_RULES) {
+        const sourcePath = path_1.default.join(sourceRulesDir, rule);
+        const destPath = path_1.default.join(destRulesDir, rule);
+        if (fs_extra_1.default.existsSync(sourcePath)) {
+            fs_extra_1.default.copySync(sourcePath, destPath);
+            copied.push(rule);
+        }
+    }
+    return copied;
+}
+async function ai(options) {
+    console.log();
+    logger_1.logger.info('DevDoc AI Agent Setup');
+    console.log();
+    const projectPath = process.cwd();
+    // Check if this is a DevDoc project
+    const docsJsonPath = path_1.default.join(projectPath, 'docs.json');
+    const hasDocsJson = fs_extra_1.default.existsSync(docsJsonPath);
+    if (!hasDocsJson) {
+        logger_1.logger.warn('No docs.json found. This may not be a DevDoc project.');
+        console.log();
+    }
+    // Get template directory
+    let templateDir;
+    try {
+        templateDir = getTemplateDir();
+    }
+    catch {
+        logger_1.logger.error('Could not find AI agent templates. Please ensure DevDoc is installed correctly.');
+        process.exit(1);
+    }
+    // Get tool selection if not provided
+    let tool = options.tool || 'both';
+    if (!options.tool) {
+        const toolChoices = [
+            { value: 'both', label: 'Both - Claude Code and Cursor' },
+            { value: 'claude', label: 'Claude Code - Skills and CLAUDE.md' },
+            { value: 'cursor', label: 'Cursor - Rules (.cursor/rules/)' },
+        ];
+        tool = await promptSelect('Which AI tool do you use?', toolChoices);
+    }
+    console.log();
+    logger_1.logger.info('Setting up AI agent configuration...');
+    console.log();
+    const results = {
+        claudeMd: false,
+        claudeSkills: [],
+        cursorRules: [],
+    };
+    // Setup Claude Code
+    if (tool === 'claude' || tool === 'both') {
+        // Copy CLAUDE.md
+        results.claudeMd = copyClaudeMd(projectPath, templateDir);
+        if (results.claudeMd) {
+            logger_1.logger.success('Created CLAUDE.md');
+        }
+        // Copy skills
+        results.claudeSkills = copyClaudeSkills(projectPath, templateDir);
+        for (const skill of results.claudeSkills) {
+            logger_1.logger.success(`Created .claude/skills/${skill}/SKILL.md`);
+        }
+    }
+    // Setup Cursor
+    if (tool === 'cursor' || tool === 'both') {
+        results.cursorRules = copyCursorRules(projectPath, templateDir);
+        for (const rule of results.cursorRules) {
+            logger_1.logger.success(`Created .cursor/rules/${rule}`);
+        }
+    }
+    // Summary
+    console.log();
+    logger_1.logger.success('AI agent configuration complete!');
+    console.log();
+    if (tool === 'claude' || tool === 'both') {
+        console.log('Available Claude Code commands:');
+        console.log('  /bootstrap-docs    - Analyze repo and generate initial documentation');
+        console.log('  /migrate-docs      - Migrate from Mintlify, Docusaurus, GitBook, etc.');
+        console.log('  /import-api-spec   - Import OpenAPI, GraphQL, or AsyncAPI specs');
+        console.log('  /sync-docs         - Find and fix outdated documentation');
+        console.log('  /check-docs        - Quick health check without changes');
+        console.log('  /create-doc-page   - Create a new documentation page');
+        console.log('  /update-docs-json  - Add pages to navigation');
+        console.log('  /generate-api-docs - Generate API documentation');
+        console.log('  /docs-from-code    - Generate docs from specific code files');
+        console.log();
+    }
+    if (tool === 'cursor' || tool === 'both') {
+        console.log('Cursor rules configured for *.mdx files.');
+        console.log();
+        console.log('Suggested prompts in Agent mode:');
+        console.log('  "Analyze this repo and generate initial documentation"');
+        console.log('  "Migrate my Mintlify docs to DevDoc format"');
+        console.log('  "Check my docs for outdated content"');
+        console.log('  "Create a new guide about authentication"');
+        console.log();
+    }
+    console.log('Quick start:');
+    if (tool === 'claude' || tool === 'both') {
+        console.log('  Claude Code: /bootstrap-docs');
+    }
+    if (tool === 'cursor' || tool === 'both') {
+        console.log('  Cursor: Ask "generate initial documentation from this repo"');
+    }
+    console.log();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.js","sourceRoot":"","sources":["../../../src/cli/commands/ai.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path';\nimport fs from 'fs-extra';\nimport { logger } from '../../utils/logger';\n\ntype AITool = 'claude' | 'cursor' | 'both';\n\ninterface AIOptions {\n  tool?: AITool;\n}\n\n// Simple prompt helper using readline\nasync function prompt(question: string, defaultValue?: string): Promise<string> {\n  const readline = await import('readline');\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    const displayQuestion = defaultValue \n      ? `${question} (${defaultValue}): `\n      : `${question}: `;\n    \n    rl.question(displayQuestion, (answer) => {\n      rl.close();\n      resolve(answer.trim() || defaultValue || '');\n    });\n  });\n}\n\nasync function promptSelect(question: string, choices: { value: string; label: string }[]): Promise<string> {\n  console.log(`\\n${question}\\n`);\n  choices.forEach((choice, i) => {\n    console.log(`  ${i + 1}. ${choice.label}`);\n  });\n  console.log();\n  \n  const readline = await import('readline');\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise((resolve) => {\n    rl.question('Enter number: ', (answer) => {\n      rl.close();\n      const index = parseInt(answer.trim(), 10) - 1;\n      if (index >= 0 && index < choices.length) {\n        resolve(choices[index].value);\n      } else {\n        // Default to first choice\n        resolve(choices[0].value);\n      }\n    });\n  });\n}\n\n// Claude Code skills to create\nconst CLAUDE_SKILLS = [\n  'bootstrap-docs',\n  'migrate-docs',\n  'import-api-spec',\n  'sync-docs',\n  'check-docs',\n  'create-doc-page',\n  'update-docs-json',\n  'generate-api-docs',\n  'docs-from-code',\n];\n\n// Cursor rules to create\nconst CURSOR_RULES = [\n  'devdoc.mdc',\n  'devdoc-bootstrap.mdc',\n  'devdoc-migrate.mdc',\n  'devdoc-sync.mdc',\n];\n\n/**\n * Get the template directory path (handles both development and installed package scenarios)\n */\nfunction getTemplateDir(): string {\n  // Try relative to this file (packages/devdoc/src/cli/commands -> packages/devdoc/templates)\n  let templateDir = path.join(__dirname, '..', '..', '..', 'templates', 'starter');\n  \n  if (fs.existsSync(templateDir)) {\n    return templateDir;\n  }\n  \n  // Try devdoc/templates at repo root (development - monorepo structure)\n  // __dirname is packages/devdoc/src/cli/commands -> go up 5 levels to repo root\n  templateDir = path.join(__dirname, '..', '..', '..', '..', '..', 'devdoc', 'templates', 'starter');\n  \n  if (fs.existsSync(templateDir)) {\n    return templateDir;\n  }\n  \n  // Try node_modules location (installed package)\n  templateDir = path.join(__dirname, '..', '..', 'templates', 'starter');\n  \n  if (fs.existsSync(templateDir)) {\n    return templateDir;\n  }\n  \n  throw new Error('Could not find template directory');\n}\n\n/**\n * Copy CLAUDE.md to project root\n */\nfunction copyClaudeMd(projectPath: string, templateDir: string): boolean {\n  const sourcePath = path.join(templateDir, 'CLAUDE.md');\n  const destPath = path.join(projectPath, 'CLAUDE.md');\n  \n  if (!fs.existsSync(sourcePath)) {\n    logger.warn('CLAUDE.md template not found');\n    return false;\n  }\n  \n  fs.copySync(sourcePath, destPath);\n  return true;\n}\n\n/**\n * Copy Claude Code skills to .claude/skills/\n */\nfunction copyClaudeSkills(projectPath: string, templateDir: string): string[] {\n  const copied: string[] = [];\n  const sourceSkillsDir = path.join(templateDir, '.claude', 'skills');\n  const destSkillsDir = path.join(projectPath, '.claude', 'skills');\n  \n  if (!fs.existsSync(sourceSkillsDir)) {\n    logger.warn('Claude skills template directory not found');\n    return copied;\n  }\n  \n  // Ensure destination directory exists\n  fs.ensureDirSync(destSkillsDir);\n  \n  for (const skill of CLAUDE_SKILLS) {\n    const sourceDir = path.join(sourceSkillsDir, skill);\n    const destDir = path.join(destSkillsDir, skill);\n    \n    if (fs.existsSync(sourceDir)) {\n      fs.copySync(sourceDir, destDir);\n      copied.push(skill);\n    }\n  }\n  \n  return copied;\n}\n\n/**\n * Copy Cursor rules to .cursor/rules/\n */\nfunction copyCursorRules(projectPath: string, templateDir: string): string[] {\n  const copied: string[] = [];\n  const sourceRulesDir = path.join(templateDir, '.cursor', 'rules');\n  const destRulesDir = path.join(projectPath, '.cursor', 'rules');\n  \n  if (!fs.existsSync(sourceRulesDir)) {\n    logger.warn('Cursor rules template directory not found');\n    return copied;\n  }\n  \n  // Ensure destination directory exists\n  fs.ensureDirSync(destRulesDir);\n  \n  for (const rule of CURSOR_RULES) {\n    const sourcePath = path.join(sourceRulesDir, rule);\n    const destPath = path.join(destRulesDir, rule);\n    \n    if (fs.existsSync(sourcePath)) {\n      fs.copySync(sourcePath, destPath);\n      copied.push(rule);\n    }\n  }\n  \n  return copied;\n}\n\nexport async function ai(options: AIOptions): Promise<void> {\n  console.log();\n  logger.info('DevDoc AI Agent Setup');\n  console.log();\n\n  const projectPath = process.cwd();\n  \n  // Check if this is a DevDoc project\n  const docsJsonPath = path.join(projectPath, 'docs.json');\n  const hasDocsJson = fs.existsSync(docsJsonPath);\n  \n  if (!hasDocsJson) {\n    logger.warn('No docs.json found. This may not be a DevDoc project.');\n    console.log();\n  }\n\n  // Get template directory\n  let templateDir: string;\n  try {\n    templateDir = getTemplateDir();\n  } catch {\n    logger.error('Could not find AI agent templates. Please ensure DevDoc is installed correctly.');\n    process.exit(1);\n  }\n\n  // Get tool selection if not provided\n  let tool: AITool = options.tool || 'both';\n  \n  if (!options.tool) {\n    const toolChoices = [\n      { value: 'both', label: 'Both - Claude Code and Cursor' },\n      { value: 'claude', label: 'Claude Code - Skills and CLAUDE.md' },\n      { value: 'cursor', label: 'Cursor - Rules (.cursor/rules/)' },\n    ];\n\n    tool = await promptSelect('Which AI tool do you use?', toolChoices) as AITool;\n  }\n\n  console.log();\n  logger.info('Setting up AI agent configuration...');\n  console.log();\n\n  const results = {\n    claudeMd: false,\n    claudeSkills: [] as string[],\n    cursorRules: [] as string[],\n  };\n\n  // Setup Claude Code\n  if (tool === 'claude' || tool === 'both') {\n    // Copy CLAUDE.md\n    results.claudeMd = copyClaudeMd(projectPath, templateDir);\n    if (results.claudeMd) {\n      logger.success('Created CLAUDE.md');\n    }\n    \n    // Copy skills\n    results.claudeSkills = copyClaudeSkills(projectPath, templateDir);\n    for (const skill of results.claudeSkills) {\n      logger.success(`Created .claude/skills/${skill}/SKILL.md`);\n    }\n  }\n\n  // Setup Cursor\n  if (tool === 'cursor' || tool === 'both') {\n    results.cursorRules = copyCursorRules(projectPath, templateDir);\n    for (const rule of results.cursorRules) {\n      logger.success(`Created .cursor/rules/${rule}`);\n    }\n  }\n\n  // Summary\n  console.log();\n  logger.success('AI agent configuration complete!');\n  console.log();\n\n  if (tool === 'claude' || tool === 'both') {\n    console.log('Available Claude Code commands:');\n    console.log('  /bootstrap-docs    - Analyze repo and generate initial documentation');\n    console.log('  /migrate-docs      - Migrate from Mintlify, Docusaurus, GitBook, etc.');\n    console.log('  /import-api-spec   - Import OpenAPI, GraphQL, or AsyncAPI specs');\n    console.log('  /sync-docs         - Find and fix outdated documentation');\n    console.log('  /check-docs        - Quick health check without changes');\n    console.log('  /create-doc-page   - Create a new documentation page');\n    console.log('  /update-docs-json  - Add pages to navigation');\n    console.log('  /generate-api-docs - Generate API documentation');\n    console.log('  /docs-from-code    - Generate docs from specific code files');\n    console.log();\n  }\n\n  if (tool === 'cursor' || tool === 'both') {\n    console.log('Cursor rules configured for *.mdx files.');\n    console.log();\n    console.log('Suggested prompts in Agent mode:');\n    console.log('  \"Analyze this repo and generate initial documentation\"');\n    console.log('  \"Migrate my Mintlify docs to DevDoc format\"');\n    console.log('  \"Check my docs for outdated content\"');\n    console.log('  \"Create a new guide about authentication\"');\n    console.log();\n  }\n\n  console.log('Quick start:');\n  if (tool === 'claude' || tool === 'both') {\n    console.log('  Claude Code: /bootstrap-docs');\n  }\n  if (tool === 'cursor' || tool === 'both') {\n    console.log('  Cursor: Ask \"generate initial documentation from this repo\"');\n  }\n  console.log();\n}\n"]}

package/dist/cli/commands/create.d.ts

@@ -2,14 +2,17 @@ declare const TEMPLATES: {
     readonly basic: {
         readonly name: "Basic";
         readonly description: "Simple documentation site with guides and pages";
+        readonly color: "#10b981";
     };
     readonly openapi: {
         readonly name: "OpenAPI";
         readonly description: "Documentation with REST API reference (OpenAPI/Swagger)";
+        readonly color: "#10b981";
     };
     readonly graphql: {
         readonly name: "GraphQL";
         readonly description: "Documentation with GraphQL API playground";
+        readonly color: "#e535ab";
     };
 };
 type TemplateType = keyof typeof TEMPLATES;