@brainfish-ai/devdoc 0.1.32 → 0.1.33

package/ai-agents/.claude/skills/sync-docs/SKILL.md

@@ -1,13 +1,47 @@
 ---
 name: sync-docs
-description: Analyze existing documentation against codebase and identify/fix outdated content
+description: Analyze existing documentation against codebase and identify/fix outdated content. Reads docType from docs.json config.
 ---
 
 ## Instructions
 
 When syncing documentation with the codebase:
 
-### Step 1: Build Documentation Inventory
+### Step 0: Locate Source Code
+
+First, determine where the source code is relative to current directory:
+- If `docs.json` exists here → you're in docs folder, source code is in `../`
+- If `package.json` and `src/` exist here → you're at repo root
+- Check both current directory AND parent directory for source files
+
+### Step 1: Get Documentation Type from Config
+
+**Read `docs.json` and check for `docType` field:**
+
+```json
+{
+  "docType": "api"  // "internal" | "api" | "product"
+}
+```
+
+**If `docType` is set:** Use that value automatically.
+
+**If `docType` is NOT set, detect from structure:**
+- Has `architecture/`, `development/` → "internal"
+- Has `api-reference/`, `sdks/` → "api"  
+- Has `features/`, `tutorials/` → "product"
+
+**If still unclear, ask:**
+"What type of documentation is this?
+1. internal - for your team
+2. api - for developers using your product
+3. product - for end users"
+
+**After user answers, save to docs.json:**
+Add `"docType": "{choice}"` to docs.json so it's remembered.
+Tell user: "Saved docType to docs.json - you won't be asked again."
+
+### Step 2: Build Documentation Inventory
 
 Scan all MDX files and extract:
 - Documented functions, classes, components

package/ai-agents/.cursor/rules/devdoc-bootstrap.mdc

@@ -7,60 +7,114 @@ globs: ["**/README.md", "**/package.json", "**/src/**", "**/lib/**"]
 
 When asked to bootstrap or generate initial documentation:
 
-## Analysis Checklist
+## Step 1: Check for docType Configuration
+
+**Read `docs.json` and check for `docType` field:**
+
+```json
+{
+  "name": "Project Name",
+  "docType": "api"  // "internal" | "api" | "product"
+}
+```
+
+**If `docType` is set:** Use that value automatically. Tell user: "Using docType: {type} from docs.json"
+
+**If `docType` is NOT set, ask:**
+
+"What type of documentation are you creating?
+1. **internal** - For your team: setup guides, architecture
+2. **api** - For developers using your product: API reference, SDKs
+3. **product** - For end users: feature guides, tutorials"
+
+**After user answers, immediately save to docs.json:**
+Add `"docType": "{choice}"` to docs.json so it's saved for future use.
+Tell user: "Saved docType: {type} to docs.json - you won't be asked again."
+
+## Step 2: Locate Source Code
+
+- If `docs.json` exists → you're in docs folder, source is in `../`
+- If `package.json` + `src/` exist → you're at repo root
+- Otherwise, ask user for source code path
+
+## Step 3: Analysis Checklist
 
 1. Read README.md for project overview
-2. Check package.json for:
-   - Project name and description
-   - Dependencies (to understand tech stack)
-   - Scripts (for CLI documentation)
+2. Check package.json for name, description, dependencies, scripts
 3. Scan source directory structure
 4. Identify API endpoints or exported functions
-5. Look for existing OpenAPI/GraphQL specs
+5. Look for OpenAPI/GraphQL specs
 6. Check for example files or tests
 
-## Documentation Generation Order
+## Step 4: Generate Based on docType
 
-1. index.mdx (homepage) - from README
-2. quickstart.mdx - installation + basic usage
-3. API reference - from specs or code analysis
-4. Feature guides - from major modules
-
-## Always Include
-
-- Real code examples from the codebase
-- Accurate installation commands
-- Links between related pages
-- TODO comments for sections needing review
-
-## File Structure to Generate
+### docType: "internal"
+```
+docs/
+├── docs.json (with "docType": "internal")
+├── index.mdx              # Project overview
+├── getting-started/
+│   ├── setup.mdx          # Dev environment setup
+│   ├── prerequisites.mdx
+│   └── first-contribution.mdx
+├── architecture/
+│   ├── overview.mdx       # System design
+│   └── folder-structure.mdx
+├── development/
+│   ├── workflow.mdx       # Git workflow, PR process
+│   ├── testing.mdx
+│   └── deployment.mdx
+└── contributing.mdx
+```
 
+### docType: "api"
 ```
 docs/
-├── docs.json           # Navigation config
-├── index.mdx           # Homepage
-├── quickstart.mdx      # Getting started
+├── docs.json (with "docType": "api")
+├── index.mdx              # Product intro
+├── quickstart.mdx         # 5-minute getting started
+├── authentication.mdx     # API keys, OAuth
 ├── guides/
-│   └── overview.mdx    # Architecture
-├── api-reference/      # If API exists
+│   └── overview.mdx
+├── api-reference/
 │   ├── introduction.mdx
+│   ├── errors.mdx
 │   └── openapi.json
-└── theme.json          # Theme config
+├── sdks/                  # If SDKs exist
+│   └── ...
+└── changelog.mdx
+```
+
+### docType: "product"
+```
+docs/
+├── docs.json (with "docType": "product")
+├── index.mdx              # Product overview
+├── getting-started/
+│   ├── quickstart.mdx
+│   └── key-concepts.mdx
+├── features/
+│   └── {feature}.mdx
+├── tutorials/
+│   └── {workflow}.mdx
+├── troubleshooting/
+│   ├── common-issues.mdx
+│   └── faq.mdx
+└── release-notes.mdx
 ```
 
-## Content Extraction
+## Content Guidelines by docType
 
-| Source | Documentation |
-|--------|---------------|
-| README.md | Homepage, overview |
-| package.json | Name, version, scripts |
-| src/index.ts | Main exports |
-| tests/ | Usage examples |
-| .env.example | Configuration options |
+| docType | Focus | Tone | Code |
+|---------|-------|------|------|
+| internal | Setup, architecture, processes | Technical | Heavy |
+| api | Endpoints, auth, examples | Technical | Heavy |
+| product | Features, workflows, FAQs | Friendly | Minimal |
 
 ## Quality Guidelines
 
 - Extract real examples, don't fabricate
-- Note areas needing human review
+- Note areas needing human review with TODO
 - Generate SEO-friendly descriptions
-- Include all installation steps
+- Match tone to audience
+- Always set `docType` in generated docs.json

package/ai-agents/.cursor/rules/devdoc-sync.mdc

@@ -7,7 +7,34 @@ globs: ["**/*.mdx", "**/docs.json"]
 
 When asked to sync, update, or check documentation:
 
-## Analysis Process
+## Step 1: Locate Source Code
+
+- If `docs.json` exists here → source code is in `../`
+- If `package.json` + `src/` exist → you're at repo root
+- Check both current directory AND parent for source files
+
+## Step 2: Get Documentation Type from Config
+
+**Read `docs.json` for `docType` field:**
+
+```json
+{ "docType": "api" }  // "internal" | "api" | "product"
+```
+
+**If `docType` is set:** Use that value automatically.
+
+**If `docType` is NOT set, detect from structure:**
+- Has `architecture/`, `development/` → "internal"
+- Has `api-reference/`, `sdks/` → "api"
+- Has `features/`, `tutorials/` → "product"
+
+**If still unclear, ask:** "What type of documentation is this?"
+
+**After user answers, save to docs.json:**
+Add `"docType": "{choice}"` to docs.json.
+Tell user: "Saved docType to docs.json - you won't be asked again."
+
+## Step 3: Analysis Process
 
 1. Compare documented APIs against source code exports
 2. Verify code examples compile/run correctly
@@ -15,6 +42,24 @@ When asked to sync, update, or check documentation:
 4. Validate all internal links resolve
 5. Identify new features needing documentation
 
+## Type-Specific Checks
+
+### For docType: "internal"
+- Dev setup instructions still work
+- Architecture diagrams match current code
+- Internal tool versions are current
+
+### For docType: "api"
+- API endpoints match OpenAPI spec
+- Auth examples are correct
+- SDK versions are current
+- Error codes are complete
+
+### For docType: "product"
+- Screenshots match current UI
+- Feature descriptions are accurate
+- Tutorials still work
+
 ## Common Outdated Patterns
 
 - Function signatures that changed
@@ -32,16 +77,6 @@ When asked to sync, update, or check documentation:
 - Create stubs for undocumented new features
 - Mark deprecated features with Warning callout
 
-## Detection Checklist
-
-| Check | How to Verify |
-|-------|---------------|
-| Function exists | Search source for export |
-| Signature matches | Compare params and return type |
-| Version current | Check package.json |
-| Route exists | Search API routes |
-| Component props | Check TypeScript interface |
-
 ## Update Patterns
 
 ### Changed Signature

package/ai-agents/CLAUDE.md

@@ -2,6 +2,15 @@
 
 This is a DevDoc documentation project using MDX (Markdown + React components).
 
+## Source Code Location
+
+If this docs folder is inside a larger repository, the source code is in the parent directory:
+- Source code: `../src/` or `../lib/`
+- Package config: `../package.json`
+- README: `../README.md`
+
+When generating documentation, always check the parent directory (`../`) for source code to document.
+
 ## Project Structure
 
 ```

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

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

package/dist/cli/commands/ai.js

@@ -125,27 +125,29 @@ function getTemplateDir() {
 }
 /**
  * Copy CLAUDE.md to project root
+ * Returns 'created' | 'updated' | 'skipped'
  */
 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;
+        return 'skipped';
     }
+    const existed = fs_extra_1.default.existsSync(destPath);
     fs_extra_1.default.copySync(sourcePath, destPath);
-    return true;
+    return existed ? 'updated' : 'created';
 }
 /**
  * Copy Claude Code skills to .claude/skills/
+ * Returns array of { skill, status: 'created' | 'updated' }
  */
 function copyClaudeSkills(projectPath, templateDir) {
-    const copied = [];
+    const results = [];
     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;
+        return results;
     }
     // Ensure destination directory exists
     fs_extra_1.default.ensureDirSync(destSkillsDir);
@@ -153,22 +155,24 @@ function copyClaudeSkills(projectPath, templateDir) {
         const sourceDir = path_1.default.join(sourceSkillsDir, skill);
         const destDir = path_1.default.join(destSkillsDir, skill);
         if (fs_extra_1.default.existsSync(sourceDir)) {
+            const existed = fs_extra_1.default.existsSync(destDir);
             fs_extra_1.default.copySync(sourceDir, destDir);
-            copied.push(skill);
+            results.push({ skill, status: existed ? 'updated' : 'created' });
         }
     }
-    return copied;
+    return results;
 }
 /**
  * Copy Cursor rules to .cursor/rules/
+ * Returns array of { rule, status: 'created' | 'updated' }
  */
 function copyCursorRules(projectPath, templateDir) {
-    const copied = [];
+    const results = [];
     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;
+        return results;
     }
     // Ensure destination directory exists
     fs_extra_1.default.ensureDirSync(destRulesDir);
@@ -176,17 +180,36 @@ function copyCursorRules(projectPath, templateDir) {
         const sourcePath = path_1.default.join(sourceRulesDir, rule);
         const destPath = path_1.default.join(destRulesDir, rule);
         if (fs_extra_1.default.existsSync(sourcePath)) {
+            const existed = fs_extra_1.default.existsSync(destPath);
             fs_extra_1.default.copySync(sourcePath, destPath);
-            copied.push(rule);
+            results.push({ rule, status: existed ? 'updated' : 'created' });
         }
     }
-    return copied;
+    return results;
+}
+/**
+ * Check if AI tools are already installed
+ */
+function checkExistingInstallation(projectPath) {
+    const claudeDir = path_1.default.join(projectPath, '.claude', 'skills');
+    const cursorDir = path_1.default.join(projectPath, '.cursor', 'rules');
+    return {
+        claude: fs_extra_1.default.existsSync(claudeDir) && fs_extra_1.default.readdirSync(claudeDir).length > 0,
+        cursor: fs_extra_1.default.existsSync(cursorDir) && fs_extra_1.default.readdirSync(cursorDir).some(f => f.startsWith('devdoc')),
+    };
 }
 async function ai(options) {
-    console.log();
-    logger_1.logger.info('DevDoc AI Agent Setup');
     console.log();
     const projectPath = process.cwd();
+    const existing = checkExistingInstallation(projectPath);
+    const isUpdate = options.update || existing.claude || existing.cursor;
+    if (isUpdate) {
+        logger_1.logger.info('DevDoc AI Agent Update');
+    }
+    else {
+        logger_1.logger.info('DevDoc AI Agent Setup');
+    }
+    console.log();
     // Check if this is a DevDoc project
     const docsJsonPath = path_1.default.join(projectPath, 'docs.json');
     const hasDocsJson = fs_extra_1.default.existsSync(docsJsonPath);
@@ -206,44 +229,82 @@ async function ai(options) {
     // 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);
+        // If updating, default to updating what's already installed
+        if (isUpdate && existing.claude && !existing.cursor) {
+            tool = 'claude';
+        }
+        else if (isUpdate && existing.cursor && !existing.claude) {
+            tool = 'cursor';
+        }
+        else {
+            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...');
+    if (isUpdate) {
+        logger_1.logger.info('Updating AI agent configuration...');
+    }
+    else {
+        logger_1.logger.info('Setting up AI agent configuration...');
+    }
     console.log();
-    const results = {
-        claudeMd: false,
-        claudeSkills: [],
-        cursorRules: [],
-    };
+    let createdCount = 0;
+    let updatedCount = 0;
     // Setup Claude Code
     if (tool === 'claude' || tool === 'both') {
         // Copy CLAUDE.md
-        results.claudeMd = copyClaudeMd(projectPath, templateDir);
-        if (results.claudeMd) {
+        const claudeMdStatus = copyClaudeMd(projectPath, templateDir);
+        if (claudeMdStatus === 'created') {
             logger_1.logger.success('Created CLAUDE.md');
+            createdCount++;
+        }
+        else if (claudeMdStatus === 'updated') {
+            logger_1.logger.success('Updated CLAUDE.md');
+            updatedCount++;
         }
         // Copy skills
-        results.claudeSkills = copyClaudeSkills(projectPath, templateDir);
-        for (const skill of results.claudeSkills) {
-            logger_1.logger.success(`Created .claude/skills/${skill}/SKILL.md`);
+        const skillResults = copyClaudeSkills(projectPath, templateDir);
+        for (const { skill, status } of skillResults) {
+            if (status === 'created') {
+                logger_1.logger.success(`Created .claude/skills/${skill}/SKILL.md`);
+                createdCount++;
+            }
+            else {
+                logger_1.logger.success(`Updated .claude/skills/${skill}/SKILL.md`);
+                updatedCount++;
+            }
         }
     }
     // 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}`);
+        const ruleResults = copyCursorRules(projectPath, templateDir);
+        for (const { rule, status } of ruleResults) {
+            if (status === 'created') {
+                logger_1.logger.success(`Created .cursor/rules/${rule}`);
+                createdCount++;
+            }
+            else {
+                logger_1.logger.success(`Updated .cursor/rules/${rule}`);
+                updatedCount++;
+            }
         }
     }
     // Summary
     console.log();
-    logger_1.logger.success('AI agent configuration complete!');
+    if (updatedCount > 0 && createdCount > 0) {
+        logger_1.logger.success(`AI agent configuration complete! (${createdCount} created, ${updatedCount} updated)`);
+    }
+    else if (updatedCount > 0) {
+        logger_1.logger.success(`AI agent configuration updated! (${updatedCount} files)`);
+    }
+    else {
+        logger_1.logger.success('AI agent configuration complete!');
+    }
     console.log();
     if (tool === 'claude' || tool === 'both') {
         console.log('Available Claude Code commands:');
@@ -276,5 +337,9 @@ async function ai(options) {
         console.log('  Cursor: Ask "generate initial documentation from this repo"');
     }
     console.log();
+    if (isUpdate) {
+        console.log('Tip: Restart Claude Code or Cursor to load the updated skills/rules.');
+        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 AI agents template directory path (handles both development and installed package scenarios)\n */\nfunction getTemplateDir(): string {\n  // Try relative to compiled dist (packages/devdoc/dist/cli/commands -> packages/devdoc/ai-agents)\n  let templateDir = path.join(__dirname, '..', '..', '..', 'ai-agents');\n  \n  if (fs.existsSync(templateDir)) {\n    return templateDir;\n  }\n  \n  // Try relative to source (packages/devdoc/src/cli/commands -> packages/devdoc/ai-agents)\n  templateDir = path.join(__dirname, '..', '..', '..', 'ai-agents');\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/dist/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  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"]}
+//# 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  update?: boolean;\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 AI agents template directory path (handles both development and installed package scenarios)\n */\nfunction getTemplateDir(): string {\n  // Try relative to compiled dist (packages/devdoc/dist/cli/commands -> packages/devdoc/ai-agents)\n  let templateDir = path.join(__dirname, '..', '..', '..', 'ai-agents');\n  \n  if (fs.existsSync(templateDir)) {\n    return templateDir;\n  }\n  \n  // Try relative to source (packages/devdoc/src/cli/commands -> packages/devdoc/ai-agents)\n  templateDir = path.join(__dirname, '..', '..', '..', 'ai-agents');\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/dist/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  throw new Error('Could not find template directory');\n}\n\n/**\n * Copy CLAUDE.md to project root\n * Returns 'created' | 'updated' | 'skipped'\n */\nfunction copyClaudeMd(projectPath: string, templateDir: string): 'created' | 'updated' | 'skipped' {\n  const sourcePath = path.join(templateDir, 'CLAUDE.md');\n  const destPath = path.join(projectPath, 'CLAUDE.md');\n  \n  if (!fs.existsSync(sourcePath)) {\n    return 'skipped';\n  }\n  \n  const existed = fs.existsSync(destPath);\n  fs.copySync(sourcePath, destPath);\n  return existed ? 'updated' : 'created';\n}\n\n/**\n * Copy Claude Code skills to .claude/skills/\n * Returns array of { skill, status: 'created' | 'updated' }\n */\nfunction copyClaudeSkills(projectPath: string, templateDir: string): { skill: string; status: 'created' | 'updated' }[] {\n  const results: { skill: string; status: 'created' | 'updated' }[] = [];\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 results;\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      const existed = fs.existsSync(destDir);\n      fs.copySync(sourceDir, destDir);\n      results.push({ skill, status: existed ? 'updated' : 'created' });\n    }\n  }\n  \n  return results;\n}\n\n/**\n * Copy Cursor rules to .cursor/rules/\n * Returns array of { rule, status: 'created' | 'updated' }\n */\nfunction copyCursorRules(projectPath: string, templateDir: string): { rule: string; status: 'created' | 'updated' }[] {\n  const results: { rule: string; status: 'created' | 'updated' }[] = [];\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 results;\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      const existed = fs.existsSync(destPath);\n      fs.copySync(sourcePath, destPath);\n      results.push({ rule, status: existed ? 'updated' : 'created' });\n    }\n  }\n  \n  return results;\n}\n\n/**\n * Check if AI tools are already installed\n */\nfunction checkExistingInstallation(projectPath: string): { claude: boolean; cursor: boolean } {\n  const claudeDir = path.join(projectPath, '.claude', 'skills');\n  const cursorDir = path.join(projectPath, '.cursor', 'rules');\n  \n  return {\n    claude: fs.existsSync(claudeDir) && fs.readdirSync(claudeDir).length > 0,\n    cursor: fs.existsSync(cursorDir) && fs.readdirSync(cursorDir).some(f => f.startsWith('devdoc')),\n  };\n}\n\nexport async function ai(options: AIOptions): Promise<void> {\n  console.log();\n  \n  const projectPath = process.cwd();\n  const existing = checkExistingInstallation(projectPath);\n  const isUpdate = options.update || existing.claude || existing.cursor;\n  \n  if (isUpdate) {\n    logger.info('DevDoc AI Agent Update');\n  } else {\n    logger.info('DevDoc AI Agent Setup');\n  }\n  console.log();\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    // If updating, default to updating what's already installed\n    if (isUpdate && existing.claude && !existing.cursor) {\n      tool = 'claude';\n    } else if (isUpdate && existing.cursor && !existing.claude) {\n      tool = 'cursor';\n    } else {\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\n  console.log();\n  if (isUpdate) {\n    logger.info('Updating AI agent configuration...');\n  } else {\n    logger.info('Setting up AI agent configuration...');\n  }\n  console.log();\n\n  let createdCount = 0;\n  let updatedCount = 0;\n\n  // Setup Claude Code\n  if (tool === 'claude' || tool === 'both') {\n    // Copy CLAUDE.md\n    const claudeMdStatus = copyClaudeMd(projectPath, templateDir);\n    if (claudeMdStatus === 'created') {\n      logger.success('Created CLAUDE.md');\n      createdCount++;\n    } else if (claudeMdStatus === 'updated') {\n      logger.success('Updated CLAUDE.md');\n      updatedCount++;\n    }\n    \n    // Copy skills\n    const skillResults = copyClaudeSkills(projectPath, templateDir);\n    for (const { skill, status } of skillResults) {\n      if (status === 'created') {\n        logger.success(`Created .claude/skills/${skill}/SKILL.md`);\n        createdCount++;\n      } else {\n        logger.success(`Updated .claude/skills/${skill}/SKILL.md`);\n        updatedCount++;\n      }\n    }\n  }\n\n  // Setup Cursor\n  if (tool === 'cursor' || tool === 'both') {\n    const ruleResults = copyCursorRules(projectPath, templateDir);\n    for (const { rule, status } of ruleResults) {\n      if (status === 'created') {\n        logger.success(`Created .cursor/rules/${rule}`);\n        createdCount++;\n      } else {\n        logger.success(`Updated .cursor/rules/${rule}`);\n        updatedCount++;\n      }\n    }\n  }\n\n  // Summary\n  console.log();\n  if (updatedCount > 0 && createdCount > 0) {\n    logger.success(`AI agent configuration complete! (${createdCount} created, ${updatedCount} updated)`);\n  } else if (updatedCount > 0) {\n    logger.success(`AI agent configuration updated! (${updatedCount} files)`);\n  } else {\n    logger.success('AI agent configuration complete!');\n  }\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  if (isUpdate) {\n    console.log('Tip: Restart Claude Code or Cursor to load the updated skills/rules.');\n    console.log();\n  }\n}\n"]}