@zeyue0329/xiaoma-cli 1.6.5 → 1.8.0

package/src/xmc/_module-installer/installer.js

@@ -1,131 +0,0 @@
-const fs = require('fs-extra');
-const path = require('node:path');
-const chalk = require('chalk');
-const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
-
-/**
- * XMC Module Installer
- * Standard module installer function that executes after IDE installations
- *
- * @param {Object} options - Installation options
- * @param {string} options.projectRoot - The root directory of the target project
- * @param {Object} options.config - Module configuration from install-config.yaml
- * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
- * @param {Object} options.logger - Logger instance for output
- * @returns {Promise<boolean>} - Success status
- */
-async function install(options) {
-  const { projectRoot, config, installedIDEs, logger } = options;
-
-  try {
-    logger.log(chalk.blue('🚀 Installing XMC Module...'));
-
-    // Check and create tech_docs directory if configured
-    if (config['tech_docs']) {
-      // Strip {project-root}/ prefix if present
-      const techDocsConfig = config['tech_docs'].replace('{project-root}/', '');
-      const techDocsPath = path.join(projectRoot, techDocsConfig);
-
-      if (await fs.pathExists(techDocsPath)) {
-        // Check if template exists, add if missing
-        const templateDest = path.join(techDocsPath, 'technical-decisions-template.md');
-        if (!(await fs.pathExists(templateDest))) {
-          const templateSource = path.join(__dirname, 'assets', 'technical-decisions-template.md');
-          if (await fs.pathExists(templateSource)) {
-            await fs.copy(templateSource, templateDest);
-            logger.log(chalk.green('✓ Added technical decisions template to existing directory'));
-          }
-        }
-      } else {
-        logger.log(chalk.yellow(`Creating technical documentation directory: ${techDocsConfig}`));
-        await fs.ensureDir(techDocsPath);
-
-        // Copy technical decisions template
-        const templateSource = path.join(__dirname, 'assets', 'technical-decisions-template.md');
-        const templateDest = path.join(techDocsPath, 'technical-decisions-template.md');
-
-        if (await fs.pathExists(templateSource)) {
-          await fs.copy(templateSource, templateDest, { overwrite: false });
-          logger.log(chalk.green('✓ Added technical decisions template'));
-        }
-      }
-    }
-
-    // Create output directory if configured
-    if (config['output_folder']) {
-      // Strip {project-root}/ prefix if present
-      const outputConfig = config['output_folder'].replace('{project-root}/', '');
-      const outputPath = path.join(projectRoot, outputConfig);
-      if (!(await fs.pathExists(outputPath))) {
-        logger.log(chalk.yellow(`Creating output directory: ${outputConfig}`));
-        await fs.ensureDir(outputPath);
-      }
-    }
-
-    // Create dev story location if configured
-    if (config['sprint_artifacts']) {
-      // Strip {project-root}/ prefix if present
-      const storyConfig = config['sprint_artifacts'].replace('{project-root}/', '');
-      const storyPath = path.join(projectRoot, storyConfig);
-      if (!(await fs.pathExists(storyPath))) {
-        logger.log(chalk.yellow(`Creating story directory: ${storyConfig}`));
-        await fs.ensureDir(storyPath);
-      }
-    }
-
-    // Handle IDE-specific configurations if needed
-    if (installedIDEs && installedIDEs.length > 0) {
-      logger.log(chalk.cyan(`Configuring XMC for IDEs: ${installedIDEs.join(', ')}`));
-
-      // Add any IDE-specific XMC configurations here
-      for (const ide of installedIDEs) {
-        await configureForIDE(ide, projectRoot, config, logger);
-      }
-    }
-
-    logger.log(chalk.green('✓ XMC Module installation complete'));
-    return true;
-  } catch (error) {
-    logger.error(chalk.red(`Error installing XMC module: ${error.message}`));
-    return false;
-  }
-}
-
-/**
- * Configure XMC module for specific platform/IDE
- * @private
- */
-async function configureForIDE(ide, projectRoot, config, logger) {
-  // Validate platform code
-  if (!platformCodes.isValidPlatform(ide)) {
-    logger.warn(chalk.yellow(`  Warning: Unknown platform code '${ide}'. Skipping XMC configuration.`));
-    return;
-  }
-
-  const platformName = platformCodes.getDisplayName(ide);
-
-  // Try to load platform-specific handler
-  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
-
-  try {
-    if (await fs.pathExists(platformSpecificPath)) {
-      const platformHandler = require(platformSpecificPath);
-
-      if (typeof platformHandler.install === 'function') {
-        await platformHandler.install({
-          projectRoot,
-          config,
-          logger,
-          platformInfo: platformCodes.getPlatform(ide), // Pass platform metadata
-        });
-      }
-    } else {
-      // No platform-specific handler for this IDE
-      logger.log(chalk.dim(`  No XMC-specific configuration for ${platformName}`));
-    }
-  } catch (error) {
-    logger.warn(chalk.yellow(`  Warning: Could not load XMC platform-specific handler for ${platformName}: ${error.message}`));
-  }
-}
-
-module.exports = { install };

package/src/xmc/_module-installer/platform-specifics/claude-code.js

@@ -1,35 +0,0 @@
-const chalk = require('chalk');
-
-/**
- * XMC Platform-specific installer for Claude Code
- *
- * @param {Object} options - Installation options
- * @param {string} options.projectRoot - The root directory of the target project
- * @param {Object} options.config - Module configuration from install-config.yaml
- * @param {Object} options.logger - Logger instance for output
- * @param {Object} options.platformInfo - Platform metadata from global config
- * @returns {Promise<boolean>} - Success status
- */
-async function install(options) {
-  const { logger, platformInfo } = options;
-  // projectRoot and config available for future use
-
-  try {
-    const platformName = platformInfo ? platformInfo.name : 'Claude Code';
-    logger.log(chalk.cyan(`  XMC-${platformName} Specifics installed`));
-
-    // Add Claude Code specific XMC configurations here
-    // For example:
-    // - Custom command configurations
-    // - Agent party configurations
-    // - Workflow integrations
-    // - Template mappings
-
-    return true;
-  } catch (error) {
-    logger.error(chalk.red(`Error installing XMC Claude Code specifics: ${error.message}`));
-    return false;
-  }
-}
-
-module.exports = { install };

package/src/xmc/_module-installer/platform-specifics/windsurf.js

@@ -1,32 +0,0 @@
-const chalk = require('chalk');
-
-/**
- * XMC Platform-specific installer for Windsurf
- *
- * @param {Object} options - Installation options
- * @param {string} options.projectRoot - The root directory of the target project
- * @param {Object} options.config - Module configuration from install-config.yaml
- * @param {Object} options.logger - Logger instance for output
- * @returns {Promise<boolean>} - Success status
- */
-async function install(options) {
-  const { logger } = options;
-  // projectRoot and config available for future use
-
-  try {
-    logger.log(chalk.cyan('  XMC-Windsurf Specifics installed'));
-
-    // Add Windsurf specific XMC configurations here
-    // For example:
-    // - Custom cascades
-    // - Workflow adaptations
-    // - Template configurations
-
-    return true;
-  } catch (error) {
-    logger.error(chalk.red(`Error installing XMC Windsurf specifics: ${error.message}`));
-    return false;
-  }
-}
-
-module.exports = { install };

package/src/xmc/sub-modules/claude-code/config.yaml

@@ -1,5 +0,0 @@
-# Powered by XIAOMA™ Core
-name: xmccc
-short-title: XMC Claude Code Sub Module
-author: Brian (XiaoMa) Madison
-submodule: true

package/src/xmc/sub-modules/claude-code/injections.yaml

@@ -1,242 +0,0 @@
-# Claude Code Content Injection Configuration
-# This file defines content to be injected at specific points in XIAOMA files
-# when Claude Code is selected as the IDE during installation
-#
-# The installer will:
-# 1. Ask users if they want to install subagents (all/selective/none)
-# 2. Ask where to install (project-level .claude/agents/{xiaoma_folder}/ or user-level ~/.claude/agents/{xiaoma_folder}/)
-# 3. Only inject content related to selected subagents
-# 4. Templates stay in {xiaoma_folder}/ directory and are referenced from there
-# 5. Injections are placed at specific sections where each subagent is most valuable
-
-injections:
-  # ===== PRD WORKFLOW INJECTIONS =====
-
-  # PRD Subagent Instructions
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "prd-subagent-instructions"
-    requires: "all-prd-subagents"
-    content: |
-
-      **Subagent Usage**: Throughout this workflow, leverage specialized subagents at critical decision points:
-      - <CRITICAL>Use `xmc-requirements-analyst` when defining functional requirements</CRITICAL>
-      - <CRITICAL>Use `xmc-user-journey-mapper` for comprehensive journey mapping</CRITICAL>
-      - <CRITICAL>Use `xmc-epic-optimizer` when structuring epic boundaries</CRITICAL>
-      - <CRITICAL>Use `xmc-technical-decisions-curator` to capture all technical mentions</CRITICAL>
-
-  # PRD Requirements Analysis
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "prd-requirements-analysis"
-    requires: "requirements-analyst"
-    content: |
-
-      **Subagent Hint**: Use `xmc-requirements-analyst` to validate requirements are testable and complete.
-
-  # PRD User Journey Mapping
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "prd-user-journey"
-    requires: "user-journey-mapper"
-    content: |
-
-      **Subagent Hint**: Use `xmc-user-journey-mapper` to map all user types and their value paths.
-
-  # PRD Epic Optimization
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "prd-epic-optimization"
-    requires: "epic-optimizer"
-    content: |
-
-      **Subagent Hint**: Use `xmc-epic-optimizer` to validate epic boundaries deliver coherent value.
-
-  # PRD Document Review
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "prd-checklist-review"
-    requires: "document-reviewer"
-    content: |
-
-      **Subagent Hint**: Use `xmc-document-reviewer` to validate PRD completeness before finalizing.
-
-  # Technical Decisions Curator
-  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
-    point: "technical-decisions-curator"
-    requires: "technical-decisions-curator"
-    content: |
-
-      **Automatic Capture**: The `xmc-technical-decisions-curator` should be invoked whenever:
-      - Technology, framework, or tool is mentioned
-      - Architecture patterns are discussed
-      - Infrastructure or deployment topics arise
-      - Integration requirements are specified
-
-  # ===== MARKET RESEARCH TEMPLATE INJECTIONS =====
-
-  # Market TAM/SAM/SOM Calculations
-  - file: "{xiaoma_folder}/xmc/templates/market.md"
-    point: "market-tam-calculations"
-    requires: "data-analyst"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to perform all TAM, SAM, and SOM calculations.</i>
-        <i>The subagent will apply proper methodologies, validate assumptions, and provide defensible market sizing.</i>
-      </llm>
-
-  # Market Trends Analysis
-  - file: "{xiaoma_folder}/xmc/templates/market.md"
-    point: "market-trends-analysis"
-    requires: "trend-spotter"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-trend-spotter' subagent to identify and analyze emerging market trends.</i>
-        <i>The subagent will detect disruption signals, technology shifts, and future opportunities.</i>
-      </llm>
-
-  # Market Customer Personas
-  - file: "{xiaoma_folder}/xmc/templates/market.md"
-    point: "market-customer-segments"
-    requires: "user-researcher"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-user-researcher' subagent to develop detailed customer segment profiles and personas.</i>
-        <i>The subagent will analyze behavior patterns, needs, and journey maps for each segment.</i>
-      </llm>
-
-  # Market Research Review
-  - file: "{xiaoma_folder}/xmc/templates/market.md"
-    point: "market-executive-summary"
-    requires: "document-reviewer"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Before finalizing the executive summary, use the 'xmc-document-reviewer' subagent to validate all market research findings and ensure data accuracy.</i>
-      </llm>
-
-  # ===== COMPETITOR ANALYSIS TEMPLATE INJECTIONS =====
-
-  # Competitor Intelligence Gathering
-  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
-    point: "competitor-intelligence"
-    requires: "market-researcher"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-market-researcher' subagent to gather comprehensive competitive intelligence for each competitor profile.</i>
-        <i>The subagent will analyze positioning, strategy, and market dynamics.</i>
-      </llm>
-
-  # Competitor Technical Analysis
-  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
-    point: "competitor-tech-stack"
-    requires: "technical-evaluator"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-technical-evaluator' subagent to analyze and compare competitor technology stacks.</i>
-        <i>The subagent will identify technical differentiators and architectural advantages.</i>
-      </llm>
-
-  # Competitor Metrics Analysis
-  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
-    point: "competitor-metrics"
-    requires: "data-analyst"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to analyze competitor performance metrics and market share data.</i>
-      </llm>
-
-  # Competitor Analysis Review
-  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
-    point: "competitor-executive-summary"
-    requires: "document-reviewer"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Before finalizing, use the 'xmc-document-reviewer' subagent to validate competitive analysis completeness and strategic recommendations.</i>
-      </llm>
-
-  # ===== PROJECT BRIEF TEMPLATE INJECTIONS =====
-
-  # Brief Problem Validation
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-problem-validation"
-    requires: "market-researcher"
-    content: |
-
-      <llm critical="true">
-        <i>IF market research has not been provided as input, MANDATORY: Use the 'xmc-market-researcher' subagent to validate the problem statement and assess market opportunity.</i>
-      </llm>
-
-  # Brief Target User Analysis
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-user-analysis"
-    requires: "user-researcher"
-    content: |
-
-      <llm critical="true">
-        <i>IF target user analysis has not been provided, MANDATORY: Use the 'xmc-user-researcher' subagent to develop detailed user profiles and validate user needs.</i>
-      </llm>
-
-  # Brief Success Metrics
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-success-metrics"
-    requires: "data-analyst"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to define and validate KPIs, success metrics, and measurement approaches.</i>
-      </llm>
-
-  # Brief Technical Feasibility
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-technical-feasibility"
-    requires: "technical-evaluator"
-    content: |
-
-      <llm critical="true">
-        <i>IF technical assumptions need validation, use the 'xmc-technical-evaluator' subagent to assess feasibility and identify technical risks.</i>
-      </llm>
-
-  # Brief Requirements Extraction
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-requirements"
-    requires: "requirements-analyst"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Use the 'xmc-requirements-analyst' subagent to extract initial high-level requirements from the brief content.</i>
-      </llm>
-
-  # Brief Document Review
-  - file: "{xiaoma_folder}/xmc/templates/brief.md"
-    point: "brief-final-review"
-    requires: "document-reviewer"
-    content: |
-
-      <llm critical="true">
-        <i>MANDATORY: Before finalizing the brief, use the 'xmc-document-reviewer' subagent to ensure completeness and internal consistency.</i>
-      </llm>
-
-# Subagents to copy
-subagents:
-  source: "sub-agents"
-  target: ".claude/agents"
-  files:
-    - "market-researcher.md"
-    - "requirements-analyst.md"
-    - "technical-evaluator.md"
-    - "epic-optimizer.md"
-    - "document-reviewer.md"
-    - "codebase-analyzer.md"
-    - "dependency-mapper.md"
-    - "pattern-detector.md"
-    - "tech-debt-auditor.md"
-    - "api-documenter.md"
-    - "test-coverage-analyzer.md"
-    - "user-researcher.md"
-    - "user-journey-mapper.md"
-    - "technical-decisions-curator.md"
-    - "data-analyst.md"
-    - "trend-spotter.md"

package/src/xmc/sub-modules/claude-code/readme.md

@@ -1,87 +0,0 @@
-# XMC Claude Code Sub-Module
-
-## Overview
-
-This sub-module provides Claude Code-specific enhancements for the XMC module, including specialized subagents and content injection for enhanced AI-assisted development workflows.
-
-## How the Installer Works
-
-When Claude Code is selected during XIAOMA installation:
-
-1. **Module Detection**: The installer checks for `sub-modules/claude-code/` in each selected module
-2. **Configuration Loading**: Reads `injections.yaml` to understand what to inject and which subagents are available
-3. **User Interaction**: Prompts users to:
-   - Choose subagent installation (all/selective/none)
-   - Select installation location (project `.claude/agents/` or user `~/.claude/agents/`)
-4. **Selective Installation**: Based on user choices:
-   - Copies only selected subagents to Claude's agents directory
-   - Injects only relevant content at defined injection points
-   - Skips injection if no subagents selected
-
-## Subagent Directory
-
-### Product Management Subagents
-
-| Subagent                 | Purpose                                  | Used By    | Recommended For                               |
-| ------------------------ | ---------------------------------------- | ---------- | --------------------------------------------- |
-| **market-researcher**    | Competitive analysis and market insights | PM Agent   | PRD creation (`*create-prd`), market analysis |
-| **requirements-analyst** | Extract and validate requirements        | PM Agent   | Requirements sections, user story creation    |
-| **technical-evaluator**  | Technology stack evaluation              | PM Agent   | Technical assumptions in PRDs                 |
-| **epic-optimizer**       | Story breakdown and sizing               | PM Agent   | Epic details, story sequencing                |
-| **document-reviewer**    | Quality checks and validation            | PM/Analyst | Final document review before delivery         |
-
-### Architecture and Documentation Subagents
-
-| Subagent                   | Purpose                                   | Used By   | Recommended For                                |
-| -------------------------- | ----------------------------------------- | --------- | ---------------------------------------------- |
-| **codebase-analyzer**      | Project structure and tech stack analysis | Architect | `*generate-context-docs` (doc-proj task)       |
-| **dependency-mapper**      | Module and package dependency analysis    | Architect | Brownfield documentation, refactoring planning |
-| **pattern-detector**       | Identify patterns and conventions         | Architect | Understanding existing codebases               |
-| **tech-debt-auditor**      | Assess technical debt and risks           | Architect | Brownfield architecture, migration planning    |
-| **api-documenter**         | Document APIs and integrations            | Architect | API documentation, service boundaries          |
-| **test-coverage-analyzer** | Analyze test suites and coverage          | Architect | Test strategy, quality assessment              |
-
-## Adding New Subagents
-
-1. **Create the subagent file** in `sub-agents/`:
-
-   ```markdown
-   ---
-   name: your-subagent-name
-   description: Brief description. use PROACTIVELY when [specific scenario]
-   tools: Read, Write, Grep # Specify required tools - check claude-code docs to see what tools are available, or just leave blank to allow all
-   ---
-
-   [System prompt describing the subagent's role and expertise]
-   ```
-
-2. **Add to injections.yaml**:
-   - Add filename to `subagents.files` list
-   - Update relevant agent injection content if needed
-
-3. **Create injection point** (if new agent):
-   ```xml
-   <!-- IDE-INJECT-POINT: agent-name-instructions -->
-   ```
-
-## Injection Points
-
-All injection points in this module are documented in: `{project-root}{output_folder}/injection-points.md` - ensure this is kept up to date.
-
-Injection points allow IDE-specific content to be added during installation without modifying source files. They use HTML comment syntax and are replaced during the installation process based on user selections.
-
-## Configuration Files
-
-- **injections.yaml**: Defines what content to inject and where
-- **config.yaml**: Additional Claude Code configuration (if needed)
-- **sub-agents/**: Directory containing all subagent definitions
-
-## Testing
-
-To test subagent installation:
-
-1. Run the XIAOMA installer
-2. Select XMC module and Claude Code
-3. Verify prompts appear for subagent selection
-4. Check `.claude/agents/` for installed subagents
-5. Verify injection points are replaced in `.claude/commands/{xiaoma_folder}/` and the various tasks and templates under `{xiaoma_folder}/...`

package/src/xmc/sub-modules/claude-code/sub-agents/xiaoma-analysis/api-documenter.md

@@ -1,102 +0,0 @@
----
-name: xmc-api-documenter
-description: Documents APIs, interfaces, and integration points including REST endpoints, GraphQL schemas, message contracts, and service boundaries. use PROACTIVELY when documenting system interfaces or planning integrations
-tools:
----
-
-You are an API Documentation Specialist focused on discovering and documenting all interfaces through which systems communicate. Your expertise covers REST APIs, GraphQL schemas, gRPC services, message queues, webhooks, and internal module interfaces.
-
-## Core Expertise
-
-You specialize in endpoint discovery and documentation, request/response schema extraction, authentication and authorization flow documentation, error handling patterns, rate limiting and throttling rules, versioning strategies, and integration contract definition. You understand various API paradigms and documentation standards.
-
-## Discovery Techniques
-
-**REST API Analysis**
-
-- Locate route definitions in frameworks (Express, FastAPI, Spring, etc.)
-- Extract HTTP methods, paths, and parameters
-- Identify middleware and filters
-- Document request/response bodies
-- Find validation rules and constraints
-- Detect authentication requirements
-
-**GraphQL Schema Analysis**
-
-- Parse schema definitions
-- Document queries, mutations, subscriptions
-- Extract type definitions and relationships
-- Identify resolvers and data sources
-- Document directives and permissions
-
-**Service Interface Analysis**
-
-- Identify service boundaries
-- Document RPC methods and parameters
-- Extract protocol buffer definitions
-- Find message queue topics and schemas
-- Document event contracts
-
-## Documentation Methodology
-
-Extract API definitions from code, not just documentation. Compare documented behavior with actual implementation. Identify undocumented endpoints and features. Find deprecated endpoints still in use. Document side effects and business logic. Include performance characteristics and limitations.
-
-## Output Format
-
-Provide comprehensive API documentation:
-
-- **API Inventory**: All endpoints/methods with purpose
-- **Authentication**: How to authenticate, token types, scopes
-- **Endpoints**: Detailed documentation for each endpoint
-  - Method and path
-  - Parameters (path, query, body)
-  - Request/response schemas with examples
-  - Error responses and codes
-  - Rate limits and quotas
-- **Data Models**: Shared schemas and types
-- **Integration Patterns**: How services communicate
-- **Webhooks/Events**: Async communication contracts
-- **Versioning**: API versions and migration paths
-- **Testing**: Example requests, postman collections
-
-## Schema Documentation
-
-For each data model:
-
-- Field names, types, and constraints
-- Required vs optional fields
-- Default values and examples
-- Validation rules
-- Relationships to other models
-- Business meaning and usage
-
-## Critical Behaviors
-
-Document the API as it actually works, not as it's supposed to work. Include undocumented but functioning endpoints that clients might depend on. Note inconsistencies in error handling or response formats. Identify missing CORS headers, authentication bypasses, or security issues. Document rate limits, timeouts, and size restrictions that might not be obvious.
-
-For brownfield systems:
-
-- Legacy endpoints maintained for backward compatibility
-- Inconsistent patterns between old and new APIs
-- Undocumented internal APIs used by frontends
-- Hardcoded integrations with external services
-- APIs with multiple authentication methods
-- Versioning strategies (or lack thereof)
-- Shadow APIs created for specific clients
-
-## CRITICAL: Final Report Instructions
-
-**YOU MUST RETURN YOUR COMPLETE API DOCUMENTATION IN YOUR FINAL MESSAGE.**
-
-Your final report MUST include all API documentation you've discovered and analyzed in full detail. Do not just describe what you found - provide the complete, formatted API documentation ready for integration.
-
-Include in your final report:
-
-1. Complete API inventory with all endpoints/methods
-2. Full authentication and authorization documentation
-3. Detailed endpoint specifications with schemas
-4. Data models and type definitions
-5. Integration patterns and examples
-6. Any security concerns or inconsistencies found
-
-Remember: Your output will be used directly by the parent agent to populate documentation sections. Provide complete, ready-to-use content, not summaries or references.