@vfarcic/dot-ai 0.115.0 → 0.117.0

package/dist/tools/organizational-data.js

@@ -246,8 +246,8 @@ function parseNumericResponse(response, validOptions) {
 /**
  * Get session file path following established pattern
  */
-function getCapabilitySessionPath(sessionId, args) {
-    const sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(args, false);
+function getCapabilitySessionPath(sessionId) {
+    const sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(false);
     const sessionSubDir = path.join(sessionDir, 'capability-sessions');
     // Ensure capability-sessions subdirectory exists
     if (!fs.existsSync(sessionSubDir)) {
@@ -258,9 +258,9 @@ function getCapabilitySessionPath(sessionId, args) {
 /**
  * Load session from file system following established pattern
  */
-function loadCapabilitySession(sessionId, args) {
+function loadCapabilitySession(sessionId) {
     try {
-        const sessionPath = getCapabilitySessionPath(sessionId, args);
+        const sessionPath = getCapabilitySessionPath(sessionId);
         if (!fs.existsSync(sessionPath)) {
             return null;
         }
@@ -268,7 +268,7 @@ function loadCapabilitySession(sessionId, args) {
         const session = JSON.parse(sessionData);
         // Update last activity
         session.lastActivity = new Date().toISOString();
-        saveCapabilitySession(session, args);
+        saveCapabilitySession(session);
         return session;
     }
     catch (error) {
@@ -279,9 +279,9 @@ function loadCapabilitySession(sessionId, args) {
 /**
  * Save session to file system following established pattern
  */
-function saveCapabilitySession(session, args) {
+function saveCapabilitySession(session) {
     try {
-        const sessionPath = getCapabilitySessionPath(session.sessionId, args);
+        const sessionPath = getCapabilitySessionPath(session.sessionId);
         fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2), 'utf8');
     }
     catch (error) {
@@ -294,7 +294,7 @@ function saveCapabilitySession(session, args) {
  */
 function getOrCreateCapabilitySession(sessionId, args, logger, requestId) {
     if (sessionId) {
-        const existing = loadCapabilitySession(sessionId, args);
+        const existing = loadCapabilitySession(sessionId);
         if (existing) {
             logger.info('Loaded existing capability session', {
                 requestId,
@@ -312,7 +312,7 @@ function getOrCreateCapabilitySession(sessionId, args, logger, requestId) {
         startedAt: new Date().toISOString(),
         lastActivity: new Date().toISOString()
     };
-    saveCapabilitySession(session, args);
+    saveCapabilitySession(session);
     logger.info('Created new capability session', {
         requestId,
         sessionId: newSessionId,
@@ -341,20 +341,20 @@ function validateCapabilityStep(session, clientStep) {
 /**
  * Transition session to next step with proper state updates
  */
-function transitionCapabilitySession(session, nextStep, updates, args) {
+function transitionCapabilitySession(session, nextStep, updates) {
     session.currentStep = nextStep;
     session.lastActivity = new Date().toISOString();
     if (updates) {
         Object.assign(session, updates);
     }
-    saveCapabilitySession(session, args);
+    saveCapabilitySession(session);
 }
 /**
  * Clean up session file after successful completion
  */
 function cleanupCapabilitySession(session, args, logger, requestId) {
     try {
-        const sessionPath = getCapabilitySessionPath(session.sessionId, args);
+        const sessionPath = getCapabilitySessionPath(session.sessionId);
         if (fs.existsSync(sessionPath)) {
             fs.unlinkSync(sessionPath);
             logger.info('Capability session cleaned up after completion', {

package/dist/tools/project-setup/discovery.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Discovery Handler - Project Setup Tool
+ * PRD #177 - Milestone 1: Core Tool Infrastructure
+ *
+ * Step 1 of workflow: Return list of files for client to scan
+ */
+import { Logger } from '../../core/error-handling';
+import { DiscoveryResponse } from './types';
+/**
+ * Handle discovery stage - Step 1 of project setup workflow
+ *
+ * Loads ALL files from ALL scopes and returns for client to scan
+ */
+export declare function handleDiscovery(logger: Logger, requestId: string): Promise<DiscoveryResponse>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/tools/project-setup/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/tools/project-setup/discovery.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAgB,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,EAAE,iBAAiB,EAAqC,MAAM,SAAS,CAAC;AAkB/E;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,iBAAiB,CAAC,CAiE5B"}

package/dist/tools/project-setup/discovery.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Discovery Handler - Project Setup Tool
+ * PRD #177 - Milestone 1: Core Tool Infrastructure
+ *
+ * Step 1 of workflow: Return list of files for client to scan
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDiscovery = handleDiscovery;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const error_handling_1 = require("../../core/error-handling");
+const generic_session_manager_1 = require("../../core/generic-session-manager");
+/**
+ * Handle discovery stage - Step 1 of project setup workflow
+ *
+ * Loads ALL files from ALL scopes and returns for client to scan
+ */
+async function handleDiscovery(logger, requestId) {
+    return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
+        logger.debug('Starting project setup discovery', { requestId });
+        // Load discovery config from source directory
+        // From dist/tools/project-setup/ -> ../../../ gets to project root, then src/tools/project-setup/
+        const configPath = path.join(__dirname, '..', '..', '..', 'src', 'tools', 'project-setup', 'discovery-config.json');
+        const configContent = fs.readFileSync(configPath, 'utf8');
+        const allConfig = JSON.parse(configContent);
+        // Collect all files from all scopes
+        const allFiles = [];
+        const scopeNames = Object.keys(allConfig);
+        for (const scopeName of scopeNames) {
+            const scopeConfig = allConfig[scopeName];
+            allFiles.push(...scopeConfig.files);
+        }
+        // Remove duplicates
+        const uniqueFiles = Array.from(new Set(allFiles));
+        // Initialize session manager with 'proj' prefix
+        const sessionManager = new generic_session_manager_1.GenericSessionManager('proj');
+        // Create new session with ALL scope configurations
+        const session = sessionManager.createSession({
+            currentStep: 'discover',
+            allScopes: allConfig, // Store all scope configurations
+            filesToCheck: uniqueFiles
+        });
+        logger.info('Project setup session created', {
+            requestId,
+            sessionId: session.sessionId,
+            scopeCount: scopeNames.length,
+            fileCount: uniqueFiles.length
+        });
+        // Return discovery response
+        const response = {
+            success: true,
+            sessionId: session.sessionId,
+            filesToCheck: uniqueFiles,
+            availableScopes: scopeNames,
+            nextStep: 'reportScan',
+            instructions: `Scan the repository for these files: ${uniqueFiles.join(', ')}. Check which files exist and build an array of those files. Then call projectSetup tool with step: "reportScan", sessionId: "${session.sessionId}", and existingFiles: [array of files that exist in the repository].`
+        };
+        logger.debug('Discovery response prepared', {
+            requestId,
+            sessionId: session.sessionId,
+            fileCount: response.filesToCheck.length,
+            scopes: scopeNames
+        });
+        return response;
+    }, {
+        operation: 'project_setup_discovery',
+        component: 'ProjectSetupTool',
+        requestId
+    });
+}

package/dist/tools/project-setup/generate-scope.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generate Scope Handler - Project Setup Tool
+ * PRD #177 - Scope-based workflow refactoring
+ *
+ * Step 3 of workflow: Generate ALL files in a scope at once
+ */
+import { Logger } from '../../core/error-handling';
+import { GenerateScopeResponse, ErrorResponse } from './types';
+/**
+ * Handle generateScope stage - Step 3 of project setup workflow
+ *
+ * Generates ALL files for a scope at once based on user answers
+ */
+export declare function handleGenerateScope(sessionId: string, scope: string | undefined, answers: Record<string, any> | undefined, logger: Logger, requestId: string): Promise<GenerateScopeResponse | ErrorResponse>;
+//# sourceMappingURL=generate-scope.d.ts.map

package/dist/tools/project-setup/generate-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-scope.d.ts","sourceRoot":"","sources":["../../../src/tools/project-setup/generate-scope.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAA2B,aAAa,EAAiB,MAAM,SAAS,CAAC;AAGvG;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,EACxC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,qBAAqB,GAAG,aAAa,CAAC,CA8JhD"}

package/dist/tools/project-setup/generate-scope.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Generate Scope Handler - Project Setup Tool
+ * PRD #177 - Scope-based workflow refactoring
+ *
+ * Step 3 of workflow: Generate ALL files in a scope at once
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGenerateScope = handleGenerateScope;
+const error_handling_1 = require("../../core/error-handling");
+const generic_session_manager_1 = require("../../core/generic-session-manager");
+const shared_prompt_loader_1 = require("../../core/shared-prompt-loader");
+/**
+ * Handle generateScope stage - Step 3 of project setup workflow
+ *
+ * Generates ALL files for a scope at once based on user answers
+ */
+async function handleGenerateScope(sessionId, scope, answers, logger, requestId) {
+    return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
+        logger.debug('Starting scope generation', { requestId, sessionId, scope });
+        // Initialize session manager
+        const sessionManager = new generic_session_manager_1.GenericSessionManager('proj');
+        // Load session
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            return {
+                success: false,
+                error: {
+                    message: `Session ${sessionId} not found`,
+                    details: 'Please start a new session with step: "discover"'
+                }
+            };
+        }
+        // Validate inputs
+        if (!scope) {
+            return {
+                success: false,
+                error: {
+                    message: 'scope is required for generateScope step',
+                    details: 'Provide the scope name (e.g., "github-community")'
+                }
+            };
+        }
+        if (!answers) {
+            return {
+                success: false,
+                error: {
+                    message: 'answers are required for generateScope step',
+                    details: 'Provide answers to the questions for this scope'
+                }
+            };
+        }
+        // Validate session state
+        if (!session.data.allScopes || !session.data.existingFiles) {
+            return {
+                success: false,
+                error: {
+                    message: 'Invalid session state',
+                    details: 'Session does not contain required data'
+                }
+            };
+        }
+        const scopeConfig = session.data.allScopes[scope];
+        if (!scopeConfig) {
+            return {
+                success: false,
+                error: {
+                    message: `Invalid scope: ${scope}`,
+                    details: `Available scopes: ${Object.keys(session.data.allScopes).join(', ')}`
+                }
+            };
+        }
+        // Get files to generate (excluding existing ones)
+        const existingFiles = session.data.existingFiles;
+        const baseFiles = scopeConfig.files.filter(file => !existingFiles.includes(file));
+        // Add conditional-only files (files that exist ONLY in conditionalFiles, not in main files array)
+        const conditionalFiles = scopeConfig.conditionalFiles || {};
+        const conditionalOnlyFiles = Object.keys(conditionalFiles).filter(file => !scopeConfig.files.includes(file) && !existingFiles.includes(file));
+        // Combine base files and conditional-only files
+        const filesToGenerate = [...baseFiles, ...conditionalOnlyFiles];
+        // Evaluate conditional files and generate content
+        const generatedFiles = [];
+        const excludedFiles = [];
+        for (const fileName of filesToGenerate) {
+            // Check if this file has conditional generation rules
+            const conditionalRule = conditionalFiles[fileName];
+            if (conditionalRule) {
+                const shouldGenerate = evaluateCondition(conditionalRule.condition, answers);
+                if (!shouldGenerate) {
+                    logger.info('File excluded due to conditional rule', {
+                        requestId,
+                        fileName,
+                        scope,
+                        condition: conditionalRule.condition,
+                        reason: conditionalRule.reason
+                    });
+                    excludedFiles.push(fileName);
+                    continue;
+                }
+            }
+            // Preprocess answers for template (convert comma-separated strings to arrays)
+            const processedAnswers = preprocessAnswers(answers);
+            // Generate file content
+            const content = generateFileContent(fileName, processedAnswers, logger);
+            generatedFiles.push({
+                path: fileName,
+                content,
+                reason: conditionalRule ? conditionalRule.reason : undefined
+            });
+            logger.info('File generated', {
+                requestId,
+                sessionId,
+                fileName,
+                scope,
+                contentLength: content.length
+            });
+        }
+        // Update session
+        session.data.currentStep = 'complete';
+        sessionManager.updateSession(sessionId, session.data);
+        logger.info('Scope generation complete', {
+            requestId,
+            sessionId,
+            scope,
+            generatedCount: generatedFiles.length,
+            excludedCount: excludedFiles.length
+        });
+        // Process additionalInstructions template if present
+        let additionalInstructions;
+        if (scopeConfig.additionalInstructions) {
+            additionalInstructions = replaceTemplateVariables(scopeConfig.additionalInstructions, answers);
+        }
+        return {
+            success: true,
+            sessionId,
+            scope,
+            files: generatedFiles,
+            excludedFiles: excludedFiles.length > 0 ? excludedFiles : undefined,
+            instructions: `Generated ${generatedFiles.length} file(s) for scope "${scope}".\n\n` +
+                `Files:\n${generatedFiles.map(f => `- ${f.path}`).join('\n')}\n\n` +
+                (excludedFiles.length > 0 ? `Excluded ${excludedFiles.length} file(s):\n${excludedFiles.map(f => `- ${f}`).join('\n')}\n\n` : '') +
+                `Write these files to your repository using the Write tool.`,
+            additionalInstructions
+        };
+    }, {
+        operation: 'project_setup_generate_scope',
+        component: 'ProjectSetupTool',
+        requestId
+    });
+}
+/**
+ * Generate file content from template using Handlebars
+ */
+function generateFileContent(fileName, answers, logger) {
+    try {
+        // Load template using shared prompt loader with Handlebars support
+        // Templates use .hbs extension (e.g., README.md -> README.md.hbs)
+        const content = (0, shared_prompt_loader_1.loadPrompt)(fileName, answers, 'src/tools/project-setup/templates', '.hbs' // Add .hbs extension to template files
+        );
+        return content;
+    }
+    catch (error) {
+        logger.error('Failed to generate file content', error, { fileName });
+        return `# ${fileName}\n\nError: Could not generate content for this file.\nTemplate may be missing at: src/tools/project-setup/templates/${fileName}.hbs\n`;
+    }
+}
+/**
+ * Evaluate conditional file generation rule
+ *
+ * Supports conditions:
+ * - "false" -> always false
+ * - "true" -> always true
+ * - "variableName === 'value'" -> check if answers[variableName] === 'value'
+ * - "variableName === true" -> check if answers[variableName] is boolean true or truthy string
+ * - OR conditions: "condition1 || condition2 || condition3"
+ */
+function evaluateCondition(condition, answers) {
+    const trimmed = condition.trim();
+    // Handle literal boolean strings
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'true')
+        return true;
+    // Handle OR conditions: split by || and evaluate each part
+    if (trimmed.includes('||')) {
+        const conditions = trimmed.split('||').map(c => c.trim());
+        return conditions.some(cond => evaluateCondition(cond, answers));
+    }
+    // Handle equality checks with boolean: "variableName === true"
+    const booleanMatch = trimmed.match(/^(\w+)\s*===\s*(true|false)$/);
+    if (booleanMatch) {
+        const [, variableName, expectedValue] = booleanMatch;
+        const actualValue = answers[variableName];
+        // Check for truthy values: boolean true, string "yes", string "true"
+        if (expectedValue === 'true') {
+            return actualValue === true || actualValue === 'true' || actualValue === 'yes';
+        }
+        // Check for falsy values
+        return actualValue === false || actualValue === 'false' || actualValue === 'no';
+    }
+    // Handle equality checks with strings: "variableName === 'value'"
+    const stringMatch = trimmed.match(/^(\w+)\s*===\s*['"]([^'"]+)['"]$/);
+    if (stringMatch) {
+        const [, variableName, expectedValue] = stringMatch;
+        return answers[variableName] === expectedValue;
+    }
+    // Unknown condition format - default to false for safety
+    return false;
+}
+/**
+ * Preprocess answers for Handlebars templates
+ * Converts comma-separated strings to arrays where needed
+ */
+function preprocessAnswers(answers) {
+    const processed = { ...answers };
+    // Convert maintainerUsernames from comma-separated string to array
+    if (processed.maintainerUsernames && typeof processed.maintainerUsernames === 'string') {
+        processed.maintainerUsernames = processed.maintainerUsernames
+            .split(',')
+            .map((username) => username.trim())
+            .filter((username) => username.length > 0);
+    }
+    return processed;
+}
+/**
+ * Replace template variables in additionalInstructions
+ * Simple replacement for {{variableName}} patterns
+ */
+function replaceTemplateVariables(template, answers) {
+    let result = template;
+    // Replace all {{variableName}} with actual values
+    for (const [key, value] of Object.entries(answers)) {
+        const pattern = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        result = result.replace(pattern, String(value || ''));
+    }
+    return result;
+}

package/dist/tools/project-setup/report-scan.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Report Scan Handler - Project Setup Tool
+ * PRD #177 - Scope-based workflow refactoring
+ *
+ * Step 2 of workflow: Return ALL questions for selected scope
+ */
+import { Logger } from '../../core/error-handling';
+import { ReportScanResponse, ErrorResponse } from './types';
+/**
+ * Handle reportScan stage - Step 2 of project setup workflow
+ *
+ * Returns all questions for the selected scope and list of files to generate
+ */
+export declare function handleReportScan(sessionId: string, existingFiles: string[] | undefined, selectedScopes: string[] | undefined, logger: Logger, requestId: string): Promise<ReportScanResponse | ErrorResponse>;
+//# sourceMappingURL=report-scan.d.ts.map

package/dist/tools/project-setup/report-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-scan.d.ts","sourceRoot":"","sources":["../../../src/tools/project-setup/report-scan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,EAAE,kBAAkB,EAA2B,aAAa,EAAE,MAAM,SAAS,CAAC;AAErF;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EAAE,GAAG,SAAS,EACnC,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,GAAG,aAAa,CAAC,CA4I7C"}

package/dist/tools/project-setup/report-scan.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Report Scan Handler - Project Setup Tool
+ * PRD #177 - Scope-based workflow refactoring
+ *
+ * Step 2 of workflow: Return ALL questions for selected scope
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReportScan = handleReportScan;
+const error_handling_1 = require("../../core/error-handling");
+const generic_session_manager_1 = require("../../core/generic-session-manager");
+/**
+ * Handle reportScan stage - Step 2 of project setup workflow
+ *
+ * Returns all questions for the selected scope and list of files to generate
+ */
+async function handleReportScan(sessionId, existingFiles, selectedScopes, logger, requestId) {
+    return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
+        logger.debug('Starting report scan analysis', { requestId, sessionId });
+        // Initialize session manager
+        const sessionManager = new generic_session_manager_1.GenericSessionManager('proj');
+        // Load session
+        const session = sessionManager.getSession(sessionId);
+        if (!session) {
+            return {
+                success: false,
+                error: {
+                    message: `Session ${sessionId} not found`,
+                    details: 'Please start a new session with step: "discover"'
+                }
+            };
+        }
+        // Validate session state
+        if (!session.data.allScopes || !session.data.filesToCheck) {
+            return {
+                success: false,
+                error: {
+                    message: 'Invalid session state',
+                    details: 'Session does not contain scope configuration data'
+                }
+            };
+        }
+        const allScopes = session.data.allScopes;
+        // Store or retrieve existingFiles
+        let filesToUse;
+        if (existingFiles !== undefined) {
+            filesToUse = existingFiles;
+            session.data.existingFiles = existingFiles;
+            sessionManager.updateSession(sessionId, session.data);
+            logger.debug('Stored existingFiles in session', { requestId, sessionId, count: existingFiles.length });
+        }
+        else if (session.data.existingFiles !== undefined) {
+            filesToUse = session.data.existingFiles;
+            logger.debug('Reusing existingFiles from session', { requestId, sessionId, count: filesToUse.length });
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: 'existingFiles is required for first reportScan call',
+                    details: 'Please provide an array of files that exist in the repository'
+                }
+            };
+        }
+        // If no scopes selected, return analysis report
+        if (!selectedScopes || selectedScopes.length === 0) {
+            // Analyze scope completeness
+            const scopeStatus = {};
+            for (const [scopeName, scopeConfig] of Object.entries(allScopes)) {
+                const missingFiles = scopeConfig.files.filter(file => !filesToUse.includes(file));
+                scopeStatus[scopeName] = {
+                    complete: missingFiles.length === 0,
+                    missingFiles
+                };
+            }
+            const incompleteScopes = Object.entries(scopeStatus)
+                .filter(([_, status]) => !status.complete)
+                .map(([scopeName, _]) => scopeName);
+            // Generate report for user to review
+            const report = generateReport(scopeStatus, allScopes);
+            logger.info('Generated scope analysis report', {
+                requestId,
+                sessionId,
+                totalScopes: Object.keys(allScopes).length,
+                incompleteScopes: incompleteScopes.length
+            });
+            const incompleteScopeNames = incompleteScopes.join('", "');
+            return {
+                success: true,
+                sessionId,
+                nextStep: 'generateScope',
+                scope: '',
+                questions: [],
+                filesToGenerate: [],
+                instructions: `${report}\n\nIncomplete scopes: ${incompleteScopes.join(', ')}\n\n**IMPORTANT**: Present each scope individually to the user. Do NOT combine or group scopes. Use exact scope names.\n\nTo proceed, call projectSetup tool again with:\n- step: "reportScan"\n- sessionId: "${sessionId}"\n- selectedScopes: ["${incompleteScopeNames}"]  (Use exact scope names from the list above)`
+            };
+        }
+        // User selected scope(s) - take first scope to generate
+        const selectedScope = selectedScopes[0];
+        const scopeConfig = allScopes[selectedScope];
+        if (!scopeConfig) {
+            return {
+                success: false,
+                error: {
+                    message: `Invalid scope: ${selectedScope}`,
+                    details: `Available scopes: ${Object.keys(allScopes).join(', ')}`
+                }
+            };
+        }
+        // Calculate which files need to be generated
+        const filesToGenerate = scopeConfig.files.filter(file => !filesToUse.includes(file));
+        // Store selected scopes in session
+        session.data.selectedScopes = selectedScopes;
+        session.data.currentStep = 'generateScope';
+        sessionManager.updateSession(sessionId, session.data);
+        logger.info('Ready to generate scope', {
+            requestId,
+            sessionId,
+            scope: selectedScope,
+            filesToGenerate: filesToGenerate.length,
+            questions: scopeConfig.questions.length
+        });
+        // Return ALL questions for this scope
+        return {
+            success: true,
+            sessionId,
+            nextStep: 'generateScope',
+            scope: selectedScope,
+            questions: scopeConfig.questions,
+            filesToGenerate,
+            instructions: `Scope: ${selectedScope}\n\nFiles to generate (${filesToGenerate.length}):\n${filesToGenerate.map(f => `- ${f}`).join('\n')}\n\nQuestions (${scopeConfig.questions.length}):\n${scopeConfig.questions.map((q, i) => `${i + 1}. ${q.question} (ID: ${q.id}${q.required ? ', required' : ''})`).join('\n')}\n\nAnalyze the repository to determine answers for these questions. Present your suggested answers as a numbered list. Once finalized, call projectSetup tool with:\n- step: "generateScope"\n- sessionId: "${sessionId}"\n- scope: "${selectedScope}"\n- answers: {${scopeConfig.questions.slice(0, 2).map(q => `"${q.id}": "value"`).join(', ')}, ...}`
+        };
+    }, {
+        operation: 'project_setup_report_scan',
+        component: 'ProjectSetupTool',
+        requestId
+    });
+}
+/**
+ * Generate human-readable report of scope analysis
+ */
+function generateReport(scopeStatus, allScopes) {
+    const lines = ['Repository Analysis:', ''];
+    for (const [scopeName, status] of Object.entries(scopeStatus)) {
+        const scopeConfig = allScopes[scopeName];
+        const totalFiles = scopeConfig.files.length;
+        const missingCount = status.missingFiles.length;
+        const existingCount = totalFiles - missingCount;
+        const statusIcon = status.complete ? '✓' : '○';
+        lines.push(`${statusIcon} ${scopeName}: ${existingCount}/${totalFiles} files exist`);
+        if (!status.complete) {
+            lines.push(`  Missing: ${status.missingFiles.join(', ')}`);
+        }
+    }
+    return lines.join('\n');
+}