@magic-ingredients/tiny-brain-local 0.8.0 → 0.10.2

package/dist/tools/persona/as.tool.js

@@ -1,34 +1,66 @@
 import { z } from 'zod';
 import { createErrorResult } from '../index.js';
-import { createDefaultProfile, PlanningService, RulesService, extractRulesFromProfile, extractDetailsFromProfile } from '@magic-ingredients/tiny-brain-core';
-import { EnhancedPersonaService } from '../../services/enhanced-persona-service.js';
-// Schema for 'as' tool
+import { createDefaultProfile, PlanningService, RulesService, LibraryClient, parsePersonaMarkdown } from '@magic-ingredients/tiny-brain-core';
+import { PersonaService } from '../../services/persona-service.js';
+import { RepoService } from '../../services/repo-service.js';
+import { AgentService } from '../../services/agent-service.js';
 const AsArgsSchema = z.object({
-    personaName: z.string().optional(), // Make optional for whoami functionality
-    createIfMissing: z.boolean().optional(),
+    personaName: z.string().optional(),
     confirmCreate: z.boolean().optional(),
 });
+// Removed conversions - TBR accepts TBL's RepoAnalysis format directly
 /**
- * Top-level 'as' tool for quick persona switching
- * This is a convenience tool that mirrors the functionality of the persona tool
- * but is exposed at the top level for easier access
+ * AS Tool - Switch personas with repository-specific agent enhancement
+ *
+ * Flow:
+ * 1. Show current persona (if no name provided)
+ * 2. Load local persona OR import from library
+ * 3. Enhance imported personas with agents
+ * 4. Activate persona in context
+ * 5. Return formatted response
  */
 export class AsTool {
     static getToolDefinition() {
         return {
             name: 'as',
-            description: "🎭 PERSONA SWITCHER 🎭\n\n⚡ INSTANT CONTEXT: Switch to or create a persona for context-aware conversations.\n\n✅ FEATURES:\n  • Activate existing personas instantly\n  • Create new personas with confirmation prompt\n  • Auto-load persona's associated files\n  • Maintain conversation context\n  • Show current persona (whoami) when called without parameters\n\n💡 USAGE:\n  • as <persona_name> [createIfMissing: true] - Switch to persona\n  • as - Show current persona details\n\n🛡️ SAFETY: New personas require confirmation to prevent accidental creation\n\n🎯 USE CASES:\n  • Project-specific contexts\n  • Different communication styles\n  • Specialized knowledge domains",
+            description: `🎭 PERSONA SWITCHER 🎭
+
+⚡ INSTANT CONTEXT: Switch to or create a persona for context-aware conversations.
+
+✅ FEATURES:
+  • Activate existing personas instantly
+  • Create new personas with confirmation prompt
+  • Rename existing personas
+  • Import from library with repository analysis
+  • Show current persona when called without parameters
+
+💡 USAGE:
+  • as - Show current persona (whoami)
+  • as <persona_name> - Switch to persona
+  • as <persona_name> <new_name> - Rename persona
+  • as library:<name> - Import from library
+  • as library:<name> <local_name> - Import and rename
+
+📝 EXAMPLES:
+  • as - Show current active persona
+  • as developer - Switch to 'developer' persona
+  • as developer fred - Rename 'developer' to 'fred'
+  • as library:developer - Import 'developer' from library
+  • as library:developer fred - Import as 'fred' locally
+
+🛡️ SAFETY: New personas require confirmation to prevent accidental creation
+
+🎯 USE CASES:
+  • Project-specific contexts
+  • Different communication styles
+  • Specialized knowledge domains
+  • Repository-aware agent installation`,
             inputSchema: {
                 type: 'object',
                 properties: {
                     personaName: {
                         type: 'string',
-                        description: 'Name of the persona to switch to (optional - omit to show current persona)',
-                    },
-                    createIfMissing: {
-                        type: 'boolean',
-                        description: "Create the persona if it doesn't exist",
-                        default: false,
+                        description: 'Persona command: name to switch to, "name newName" to rename, or "library:name [localName]" to import',
                     },
                     confirmCreate: {
                         type: 'boolean',
@@ -40,150 +72,24 @@ export class AsTool {
             },
         };
     }
+    /**
+     * Main execution entry point
+     */
     static async execute(args, context) {
+        context.logger.debug('[As tool] [execute]');
+        // Cast to LocalRequestContext to access auth token
+        const localContext = context;
         try {
             const validatedArgs = AsArgsSchema.parse(args);
-            // If no personaName provided, return current persona (whoami functionality)
+            // Handle "whoami" functionality
             if (!validatedArgs.personaName) {
-                // Check if there's an active persona in context
-                if (!context.activePersona || !context.activePersona.id) {
-                    return createErrorResult('No active persona. Use "as <persona_name>" to switch to a persona.');
-                }
-                const currentPersonaName = context.activePersona.id;
-                // Load optimized context for the current persona
-                // Note: No need to switch persona here since we're just showing current state
-                const optimizedResponse = await AsTool.loadOptimizedContext(currentPersonaName, context);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(optimizedResponse, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            // Create enhanced service with RequestContext
-            const service = new EnhancedPersonaService(context);
-            // Load persona using new pattern with explicit args
-            let personaProfile = await service.loadPersona({
-                personaName: validatedArgs.personaName
-            });
-            if (!personaProfile) {
-                // Try to import from library if not found locally
-                try {
-                    const importedName = await service.importLibraryPersonaByName(validatedArgs.personaName);
-                    if (importedName) {
-                        // Successfully imported from library - message can be shown later if needed
-                        // const message = importedName !== validatedArgs.personaName
-                        //   ? `Imported library persona as '${importedName}' (name conflict with existing local persona)`
-                        //   : `Imported library persona '${importedName}'`;
-                        // Load the newly imported persona
-                        personaProfile = await service.loadPersona({
-                            personaName: importedName
-                        });
-                        // Update the args to use the actual imported name
-                        validatedArgs.personaName = importedName;
-                    }
-                    else {
-                        // Not found in library either (or not authenticated), check if we should create
-                        const availablePersonas = await service.listPersonas({});
-                        const availableList = availablePersonas.length > 0
-                            ? `Available personas: ${availablePersonas.join(', ')}`
-                            : 'No personas available.';
-                        if (!validatedArgs.createIfMissing) {
-                            return createErrorResult(`Persona '${validatedArgs.personaName}' not found. ${availableList} Use createIfMissing: true to create it.`);
-                        }
-                    }
-                }
-                catch {
-                    // If library import fails for any reason, fall back to local-only behavior
-                    const availablePersonas = await service.listPersonas({});
-                    const availableList = availablePersonas.length > 0
-                        ? `Available personas: ${availablePersonas.join(', ')}`
-                        : 'No personas available.';
-                    if (!validatedArgs.createIfMissing) {
-                        return createErrorResult(`Persona '${validatedArgs.personaName}' not found. ${availableList} Use createIfMissing: true to create it.`);
-                    }
-                }
-            }
-            // Continue with existing logic if persona still doesn't exist and createIfMissing is true
-            if (!personaProfile) {
-                // Get available personas for display
-                const availablePersonas = await service.listPersonas({});
-                // If createIfMissing is true but no explicit confirmation, prompt for it
-                if (validatedArgs.createIfMissing && !validatedArgs.confirmCreate) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    requiresConfirmation: true,
-                                    action: 'createPersona',
-                                    personaName: validatedArgs.personaName,
-                                    message: `Persona "${validatedArgs.personaName}" doesn't exist. Would you like to create it?`,
-                                    availablePersonas: availablePersonas.length > 0 ? availablePersonas : undefined,
-                                    hint: 'To confirm creation, call the tool again with confirmCreate: true',
-                                }, null, 2),
-                            },
-                        ],
-                        isError: false,
-                    };
-                }
-            }
-            if (!personaProfile && validatedArgs.createIfMissing && validatedArgs.confirmCreate) {
-                // Create new persona with confirmation
-                const profileString = createDefaultProfile(validatedArgs.personaName, new Date().toISOString());
-                // Create persona using new pattern with explicit args
-                await service.createPersona({
-                    personaName: validatedArgs.personaName,
-                    profile: profileString
-                });
-                // Load the created persona to get the full PersonaProfile
-                personaProfile = await service.loadPersona({
-                    personaName: validatedArgs.personaName
-                });
-            }
-            // Set the active persona using the callback for subsequent tools
-            if (personaProfile && context.updateActivePersona) {
-                // Create a minimal PersonaProfile object for the context
-                const activePersona = {
-                    id: validatedArgs.personaName,
-                    userContent: {
-                        profile: typeof personaProfile.profile === 'string' ? personaProfile.profile : undefined,
-                    },
-                };
-                context.logger.info(`AS tool calling updateActivePersona with persona: ${validatedArgs.personaName}`);
-                context.updateActivePersona(activePersona);
-                context.logger.info(`AS tool completed updateActivePersona call`);
-                // Load optimized persona context for AI AFTER persona is switched
-                const optimizedResponse = await AsTool.loadOptimizedContext(validatedArgs.personaName, context);
-                // Return clean context for AI (no operational metadata)
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(optimizedResponse, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            else {
-                context.logger.warn(`AS tool: Cannot update active persona - ${!personaProfile ? 'no profile' : 'no callback'}`);
-                // Load optimized persona context for AI (fallback without persona switch)
-                const optimizedResponse = await AsTool.loadOptimizedContext(validatedArgs.personaName, context);
-                // Return clean context for AI (no operational metadata)
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(optimizedResponse, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
+                return AsTool.handleShowCurrentPersona(context);
             }
+            // Switch to specified persona (pass localContext)
+            return AsTool.handleSwitchPersona({
+                personaName: validatedArgs.personaName,
+                confirmCreate: validatedArgs.confirmCreate
+            }, localContext);
         }
         catch (error) {
             if (error instanceof z.ZodError) {
@@ -193,194 +99,423 @@ export class AsTool {
         }
     }
     /**
-     * Load optimized context focused on actionable AI guidance
+     * Handle showing the current active persona
      */
-    static async loadOptimizedContext(personaName, context) {
-        try {
-            // 1. Load Rules (cross-persona directives)
-            const rulesService = new RulesService(context);
-            const rules = await rulesService.loadRulesForUser(context.userId);
-            // Add default rules if none exist
-            if (rules.length === 0) {
-                // No default rules - let the user define their own
-                context.logger.debug('No rules defined for user');
+    static async handleShowCurrentPersona(context) {
+        context.logger.debug('No persona specified: showing current persona');
+        if (!context.activePersona?.id) {
+            // Not an error - just helpful guidance
+            const service = new PersonaService(context);
+            const availablePersonas = await service.listPersonas({});
+            let helpMessage = '## No Active Persona\n\n';
+            helpMessage += 'No persona is currently selected.\n\n';
+            if (availablePersonas.length > 0) {
+                helpMessage += '### Available Personas:\n';
+                availablePersonas.forEach(persona => {
+                    helpMessage += `- ${persona}\n`;
+                });
+                helpMessage += '\n';
             }
-            // 2. Load Persona Profile and Patterns
-            const service = new EnhancedPersonaService(context);
-            const fullContext = await service.loadPersona({ personaName });
-            if (!fullContext) {
-                throw new Error(`Persona ${personaName} not found`);
+            helpMessage += '### How to use:\n';
+            helpMessage += '- `as <persona_name>` - Switch to a persona\n';
+            helpMessage += '- `as library:<name>` - Import from library\n';
+            helpMessage += '- `manage_personas list` - See all personas with details\n';
+            return {
+                content: [{
+                        type: 'text',
+                        text: helpMessage,
+                    }],
+                isError: false,
+            };
+        }
+        // Load and parse the current persona
+        const service = new PersonaService(context);
+        const persona = await service.loadPersona({ personaName: context.activePersona.id });
+        if (!persona?.profile) {
+            return createErrorResult(`Failed to load current persona '${context.activePersona.id}'`);
+        }
+        const parsedPersona = parsePersonaMarkdown(typeof persona.profile === 'string' ? persona.profile : JSON.stringify(persona.profile));
+        // Override with actual persona name from context (id is the persona name)
+        if (context.activePersona?.id) {
+            parsedPersona.name = context.activePersona.id;
+        }
+        // Get context file path for agent info
+        const agentService = new AgentService(context);
+        const formatter = agentService.getDefaultFormatter();
+        const contextFilePath = formatter.getRepoContextFilePath();
+        const response = await AsTool.buildResponse(context, parsedPersona, contextFilePath);
+        return {
+            content: [{
+                    type: 'text',
+                    text: AsTool.formatResponse(response, contextFilePath),
+                }],
+            isError: false,
+        };
+    }
+    /**
+     * Handle persona switch/creation with clear flow
+     */
+    static async handleSwitchPersona(args, context) {
+        context.logger.debug(`[As tool] [handleSwitchPersona: ${args.personaName} ]`);
+        const fullPersonaName = args.personaName;
+        // Check if this is a library persona request
+        if (fullPersonaName.startsWith('library:')) {
+            return AsTool.handleLibraryPersona(fullPersonaName, context);
+        }
+        // Parse potential rename: "personaName newName"
+        const parts = fullPersonaName.split(/\s+/);
+        const personaName = parts[0];
+        const newName = parts.length > 1 ? parts.slice(1).join(' ') : null;
+        // Local persona flow
+        const personaService = new PersonaService(context);
+        const exists = await personaService.exists(personaName);
+        if (exists) {
+            context.logger.debug(`[As tool] [handleSwitchPersona] persona already exists`);
+            // Check if this is a rename operation
+            if (newName) {
+                context.logger.debug('[As tool] [handleSwitchPersona] found persona name and rename');
+                return AsTool.handlePersonaRename(personaName, newName, personaService, context);
             }
-            const profileContent = typeof fullContext.profile === 'string'
-                ? fullContext.profile
-                : JSON.stringify(fullContext.profile, null, 2);
-            // 3. Load Active Plan for the specific persona
-            // Create a context with the correct persona to get the right plan
-            const personaContext = {
-                ...context,
-                activePersona: {
-                    id: personaName,
-                    userContent: {
-                        profile: profileContent
-                    }
-                }
+            // Switch to existing persona
+            context.logger.debug('[As tool] [handleSwitchPersona] switching to existing persona');
+            const profile = await personaService.loadPersona({ personaName });
+            if (!profile) {
+                return createErrorResult(`[As tool] [handleSwitchPersona] failed to load persona '${personaName}'`);
+            }
+            // Parse the persona
+            const parsedPersona = parsePersonaMarkdown(typeof profile.profile === 'string' ? profile.profile : JSON.stringify(profile.profile));
+            // Override the parsed name with the actual persona name from the folder
+            parsedPersona.name = personaName;
+            // Get context file path for agent info
+            const agentService = new AgentService(context);
+            const formatter = agentService.getDefaultFormatter();
+            const contextFilePath = formatter?.getRepoContextFilePath();
+            // Activate persona and return response with updated context
+            const updatedContext = await AsTool.activatePersona(personaName, profile, context);
+            const response = await AsTool.buildResponse(updatedContext, parsedPersona, contextFilePath);
+            return {
+                content: [{
+                        type: 'text',
+                        text: AsTool.formatResponse(response, contextFilePath),
+                    }],
+                isError: false,
             };
-            const planningService = new PlanningService(personaContext);
-            const activePlan = await planningService.getActivePlan();
-            let activePlanContext = null;
-            if (activePlan) {
-                // Get recent completed todos and next actions
-                const recentProgress = [];
-                const nextActions = [];
-                const blockers = [];
-                if (activePlan.phases) {
-                    activePlan.phases.forEach(phase => {
-                        if (phase.status === 'completed' && phase.todos) {
-                            phase.todos.slice(-2).forEach(todo => {
-                                if (todo.completed) {
-                                    recentProgress.push(todo.content);
-                                }
-                            });
-                        }
-                        if (phase.status === 'in_progress' && phase.todos) {
-                            phase.todos.forEach(todo => {
-                                if (!todo.completed) {
-                                    nextActions.push(todo.content);
-                                }
-                            });
-                        }
-                    });
-                }
-                // Get blockers from plan metadata
-                if (activePlan.metadata?.blockers) {
-                    activePlan.metadata.blockers.forEach(blocker => {
-                        blockers.push(blocker.description);
-                    });
+        }
+        else {
+            // Persona doesn't exist - confirm creation
+            return AsTool.handlePersonaNotFound({ personaName, confirmCreate: args.confirmCreate }, personaService, context);
+        }
+    }
+    /**
+     * Handle library persona import - simplified to only import persona
+     */
+    static async handleLibraryPersona(personaName, context) {
+        // Parse library:sourceName targetName
+        // e.g., "library:developer fred" → fetch "developer", create as "fred"
+        const afterPrefix = personaName.substring('library:'.length).trim();
+        const parts = afterPrefix.split(/\s+/);
+        const libraryPersonaName = parts[0];
+        const localPersonaName = parts.slice(1).join(' ') || libraryPersonaName;
+        if (!libraryPersonaName) {
+            return createErrorResult('Invalid library persona format. Use: library:<persona_name> [local_name]');
+        }
+        // Check auth
+        if (!context.authToken?.token) {
+            return createErrorResult('authentication required to fetch library personas');
+        }
+        try {
+            // Step 1: Fetch library persona
+            const libraryClient = new LibraryClient();
+            const personaResponse = await libraryClient.getPersona(libraryPersonaName, context.authToken?.token || '', false // Without agents
+            );
+            // Step 2: Create local persona
+            const personaService = new PersonaService(context);
+            // Handle both response formats
+            const personaData = typeof personaResponse === 'string'
+                ? { systemBlock: personaResponse }
+                : personaResponse.systemBlock
+                    ? personaResponse
+                    : { systemBlock: personaResponse.persona?.systemBlock || JSON.stringify(personaResponse) };
+            const enhancedPersona = personaService.addUserBlock(personaData, localPersonaName);
+            // Step 3: Create metadata
+            const metadata = {
+                id: localPersonaName,
+                name: localPersonaName,
+                description: personaResponse.description || `${personaResponse.name} persona`,
+                created: new Date().toISOString(),
+                lastUpdated: new Date().toISOString(),
+                sourceLibrary: {
+                    id: personaResponse.id,
+                    name: libraryPersonaName,
+                    version: personaResponse.version || '1.0.0',
+                    importedAt: new Date().toISOString()
                 }
-                const currentPhase = activePlan.phases?.find(p => p.status === 'in_progress');
-                activePlanContext = {
-                    id: activePlan.id,
-                    title: activePlan.title || 'Untitled Plan',
-                    goal: activePlan.overview || '',
-                    current_phase: currentPhase?.title || 'Planning',
-                    next_actions: nextActions.slice(0, 5),
-                    recent_progress: recentProgress.slice(0, 5),
-                    blockers
-                };
-            }
-            // 4. Extract persona-specific rules from profile
-            const personaRules = extractRulesFromProfile(profileContent);
-            // 5. Extract other profile sections
-            const background = AsTool.extractBackground(profileContent);
-            const communicationStyle = AsTool.extractCommunicationStyleText(profileContent);
-            const details = extractDetailsFromProfile(profileContent);
-            // 6. Build persona object with only non-empty fields
-            const persona = {
-                name: personaName,
-                rules: personaRules
             };
-            if (background)
-                persona.background = background;
-            if (communicationStyle)
-                persona.communication_style = communicationStyle;
-            if (details)
-                persona.details = details;
-            // Only add expertise if non-empty
-            if (fullContext.insights?.expertise && fullContext.insights.expertise.length > 0) {
-                persona.expertise = fullContext.insights.expertise;
-            }
-            // Only add learned patterns if they have content
-            const preferences = fullContext.insights?.preferences || [];
-            const avoidPatterns = AsTool.extractAvoidPatterns(fullContext.insights);
-            if (preferences.length > 0 || avoidPatterns.length > 0) {
-                persona.learned_patterns = {
-                    preferences,
-                    avoid: avoidPatterns
-                };
+            // Step 4: Create the persona and get parsed result
+            const parsedPersona = await personaService.create(localPersonaName, enhancedPersona, metadata);
+            context.logger.info(`Imported library persona '${libraryPersonaName}' as '${localPersonaName}'`);
+            // Step 5: Activate persona
+            const updatedContext = await AsTool.activatePersona(localPersonaName, { profile: enhancedPersona.systemBlock }, context);
+            // Step 6: Check if in repository and if it needs initialization
+            const repoService = new RepoService(context);
+            let needsInitMessage = '';
+            if (repoService.isInRepository()) {
+                const initialized = await repoService.isRepositoryInitialized();
+                if (!initialized) {
+                    needsInitMessage = '\n\n📝 Note: Repository not initialized. Run `analyse` to fetch recommended agents for your tech stack.';
+                }
             }
-            // 7. Build response with only necessary fields
-            const response = {
-                RULES: rules,
-                PERSONA: persona
+            // Step 7: Get context file path for agent info (if available)
+            const agentService = new AgentService(context);
+            const formatter = agentService.getDefaultFormatter();
+            const contextFilePath = formatter?.getRepoContextFilePath();
+            // Step 8: Build and return response
+            const response = await AsTool.buildResponse(updatedContext, parsedPersona, contextFilePath);
+            return {
+                content: [{
+                        type: 'text',
+                        text: AsTool.formatResponse(response, contextFilePath) + needsInitMessage,
+                    }],
+                isError: false,
             };
-            // Only add active plan if it exists
-            if (activePlanContext) {
-                response.ACTIVE_PLAN = activePlanContext;
-            }
-            return response;
         }
         catch (error) {
-            context.logger.error(`Failed to load optimized context for ${personaName}:`, error);
-            // Return minimal context on error
-            return {
-                RULES: [],
-                PERSONA: {
-                    name: personaName,
-                    rules: []
+            context.logger.error(`Failed to fetch library persona: ${error}`);
+            return createErrorResult(`Failed to fetch library persona: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Activate persona in context and return updated context
+     */
+    static async activatePersona(personaName, profile, context) {
+        // Update the active persona in context and get the new context
+        if (context.updateActivePersona) {
+            const newContext = await context.updateActivePersona({
+                id: personaName,
+                userContent: {
+                    profile: profile.profile || profile
                 }
-            };
+            });
+            return newContext || context; // Return new context or original if update doesn't return one
         }
+        return context;
     }
     /**
-     * Extract background from profile markdown
+     * Build persona response data structure
      */
-    static extractBackground(profile) {
-        if (!profile)
-            return undefined;
-        const match = profile.match(/##\s+Background\s*\n([\s\S]*?)(?=\n##|\n#|$)/i);
-        if (match && match[1]) {
-            const background = match[1].trim();
-            return background || undefined;
+    static async buildResponse(context, parsedPersona, _contextFilePath // Used in formatResponse, not here
+    ) {
+        const rulesService = new RulesService(context);
+        const planningService = new PlanningService(context);
+        // Get additional rules from rules service
+        const allRules = await rulesService.getAllRules(parsedPersona.name);
+        const additionalUserRules = allRules?.rules || [];
+        // Get active plan if any
+        let activePlan = null;
+        try {
+            activePlan = await planningService.getActivePlan();
+        }
+        catch {
+            context.logger.debug('No active persona for plan lookup');
+        }
+        // Note: contextFilePath is passed but not used here since we removed AGENT USAGE INSTRUCTIONS
+        // It's used later in formatResponse to add the reminder to re-read CLAUDE.md
+        const response = {
+            PERSONA: {
+                name: parsedPersona.name,
+                "GOLDEN RULES": additionalUserRules,
+                "USER RULES": parsedPersona.user?.rules || [],
+                "USER DETAILS": parsedPersona.user?.details || {},
+                "SYSTEM RULES": parsedPersona.system?.rules || [],
+                "SYSTEM DETAILS": parsedPersona.system?.details || {}
+            }
+        };
+        if (activePlan) {
+            // Extract just the first line or a short summary of the plan
+            let goalSummary = '';
+            if (activePlan.overview) {
+                const lines = activePlan.overview.split('\n').filter(l => l.trim());
+                goalSummary = lines[0] || activePlan.title;
+                // Truncate if still too long
+                if (goalSummary.length > 200) {
+                    goalSummary = goalSummary.substring(0, 197) + '...';
+                }
+            }
+            else {
+                goalSummary = activePlan.title;
+            }
+            response.ACTIVE_PLAN = {
+                id: activePlan.id,
+                title: activePlan.title,
+                goal: goalSummary,
+                current_phase: activePlan.currentState?.phaseTitle || '',
+                next_actions: activePlan.currentState?.nextAction ? [activePlan.currentState.nextAction.description] : [],
+                blockers: activePlan.metadata?.blockers?.map((b) => b.description)
+            };
         }
-        return undefined;
+        return response;
     }
     /**
-     * Extract communication style from profile markdown
+     * Format the persona response as human-readable markdown with enforced workflow
      */
-    static extractCommunicationStyleText(profile) {
-        if (!profile)
-            return undefined;
-        const match = profile.match(/##\s+Communication Style\s*\n([\s\S]*?)(?=\n##|\n#|$)/i);
-        if (match && match[1]) {
-            const style = match[1].trim();
-            return style || undefined;
+    static formatResponse(response, contextFilePath) {
+        let formatted = `# THIS IS YOUR CONTEXT FOR THIS SESSION - YOU MUST USE IT\n\n`;
+        formatted += `IMPORTANT: USER RULES and USER DETAILS ALWAYS take precedence over SYSTEM RULES and SYSTEM DETAILS. When there are conflicts, follow the user's preferences.\n\n`;
+        formatted += `## PERSONA: ${response.PERSONA.name}\n\n`;
+        // Golden Rules
+        if (response.PERSONA["GOLDEN RULES"] && response.PERSONA["GOLDEN RULES"].length > 0) {
+            formatted += `### GOLDEN RULES\n`;
+            response.PERSONA["GOLDEN RULES"].forEach(rule => {
+                formatted += `- ${rule}\n`;
+            });
+            formatted += '\n';
+        }
+        // User Rules
+        if (response.PERSONA["USER RULES"] && response.PERSONA["USER RULES"].length > 0) {
+            formatted += `### USER RULES\n`;
+            response.PERSONA["USER RULES"].forEach(rule => {
+                formatted += `- ${rule}\n`;
+            });
+            formatted += '\n';
+        }
+        // User Details
+        const userDetails = response.PERSONA["USER DETAILS"];
+        if (userDetails && Object.keys(userDetails).length > 0) {
+            formatted += `### USER DETAILS\n`;
+            Object.entries(userDetails).forEach(([key, value]) => {
+                formatted += `#### ${key}\n${value}\n\n`;
+            });
         }
-        return undefined;
+        // System Rules
+        if (response.PERSONA["SYSTEM RULES"] && response.PERSONA["SYSTEM RULES"].length > 0) {
+            formatted += `### SYSTEM RULES\n`;
+            response.PERSONA["SYSTEM RULES"].forEach(rule => {
+                formatted += `- ${rule}\n`;
+            });
+            formatted += '\n';
+        }
+        // System Details
+        const systemDetails = response.PERSONA["SYSTEM DETAILS"];
+        if (systemDetails && Object.keys(systemDetails).length > 0) {
+            formatted += `### SYSTEM DETAILS\n`;
+            Object.entries(systemDetails).forEach(([key, value]) => {
+                formatted += `#### ${key}\n${value}\n\n`;
+            });
+        }
+        // Active Plan - Keep it concise
+        if (response.ACTIVE_PLAN) {
+            formatted += `### ACTIVE PLAN\n`;
+            formatted += `**${response.ACTIVE_PLAN.title}**\n`;
+            if (response.ACTIVE_PLAN.goal && response.ACTIVE_PLAN.goal !== response.ACTIVE_PLAN.title) {
+                formatted += `${response.ACTIVE_PLAN.goal}\n`;
+            }
+            formatted += `\n`;
+            formatted += `- Current Phase: ${response.ACTIVE_PLAN.current_phase || 'Not specified'}\n`;
+            if (response.ACTIVE_PLAN.next_actions && response.ACTIVE_PLAN.next_actions.length > 0) {
+                formatted += `- Next Action: ${response.ACTIVE_PLAN.next_actions[0]}\n`;
+            }
+            if (response.ACTIVE_PLAN.blockers && response.ACTIVE_PLAN.blockers.length > 0) {
+                formatted += `- Blockers: ${response.ACTIVE_PLAN.blockers.length} active\n`;
+            }
+        }
+        // REFLECTION REQUIREMENT
+        formatted += `\n## 🔍 MANDATORY REFLECTION - AFTER EVERY TOOL USE\n\n`;
+        formatted += `After using ANY tool, you MUST ask yourself:\n`;
+        formatted += `- Was this the right phase for this action?\n`;
+        formatted += `- Should I have used a specialized agent instead?\n`;
+        formatted += `- Am I following the checklist workflow?\n`;
+        formatted += `- Does this align with the user's actual request?\n\n`;
+        // Add reminder to re-read context file if in a repo with agents installed
+        if (contextFilePath) {
+            formatted += `---\n\n`;
+            formatted += `**⚡ AGENT ORCHESTRATION REQUIRED**\n\n`;
+            formatted += `**RE-READ ${contextFilePath} to understand available agents for this repository.**\n`;
+            formatted += `**DEFAULT BEHAVIOR**: Use Task tool with specialized agents\n`;
+            formatted += `**EXCEPTION**: Only skip agents if you can explicitly justify why none apply\n\n`;
+            formatted += `**MANDATORY CONFIRMATION:** When ready to proceed, you MUST respond with exactly this format (copy it exactly, do not modify):\n\n`;
+            formatted += `\`\`\`\n`;
+            formatted += `    ✅ Loaded context\n`;
+            formatted += `    ✅ Re-read ${contextFilePath}\n`;
+            formatted += `    ✅ Completed pre-flight checklist\n`;
+            formatted += `    ✅ Ready for agent-first workflow\n`;
+            formatted += `    \n\n`;
+            formatted += `    I've switched to your **${response.PERSONA.name}** persona.\n`;
+            formatted += `    \n`;
+            formatted += `    🧠 Dashboard available at: [http://localhost:8765](http://localhost:8765)\n`;
+            formatted += `\`\`\`\n\n`;
+        }
+        else {
+            // Add persona switch confirmation message when no context file
+            formatted += `I've switched to your **${response.PERSONA.name}** persona.\n\n`;
+            formatted += `🧠 Dashboard available at: [http://localhost:8765](http://localhost:8765)\n`;
+        }
+        return formatted;
     }
     /**
-     * Extract patterns to avoid from insights
+     * Handle renaming an existing persona
      */
-    static extractAvoidPatterns(insights) {
-        if (!insights || !insights.patterns)
-            return [];
-        const avoidPatterns = [];
-        // Look for patterns that indicate things to avoid
-        insights.patterns.forEach((pattern) => {
-            const lowerPattern = pattern.toLowerCase();
-            if (lowerPattern.includes('avoid') ||
-                lowerPattern.includes('never') ||
-                lowerPattern.includes('don\'t') ||
-                lowerPattern.includes('do not') ||
-                lowerPattern.includes('should not') ||
-                lowerPattern.includes('must not')) {
-                avoidPatterns.push(pattern);
+    static async handlePersonaRename(oldName, newName, service, context) {
+        try {
+            // Use storage renamePersona method
+            await context.storage.renamePersona(oldName, newName, context.userId);
+            // Load and activate the renamed persona
+            const profile = await service.loadPersona({ personaName: newName });
+            if (!profile) {
+                return createErrorResult(`Failed to load renamed persona '${newName}'`);
             }
-        });
-        // Also check preferences for negative patterns
-        if (insights.preferences) {
-            insights.preferences.forEach((pref) => {
-                const lowerPref = pref.toLowerCase();
-                if (lowerPref.includes('avoid') ||
-                    lowerPref.includes('never') ||
-                    lowerPref.includes('don\'t') ||
-                    lowerPref.includes('do not')) {
-                    if (!avoidPatterns.includes(pref)) {
-                        avoidPatterns.push(pref);
-                    }
-                }
-            });
+            // Parse the persona
+            const parsedPersona = parsePersonaMarkdown(typeof profile.profile === 'string' ? profile.profile : JSON.stringify(profile.profile));
+            // Override with the new name being set
+            parsedPersona.name = newName;
+            // Get context file path for agent info
+            const agentService = new AgentService(context);
+            const formatter = agentService.getDefaultFormatter();
+            const contextFilePath = formatter?.getRepoContextFilePath();
+            const updatedContext = await AsTool.activatePersona(newName, profile, context);
+            context.logger.info(`Renamed persona '${oldName}' to '${newName}'`);
+            // Return response showing the renamed persona is now active with updated context
+            const response = await AsTool.buildResponse(updatedContext, parsedPersona, contextFilePath);
+            return {
+                content: [{
+                        type: 'text',
+                        text: AsTool.formatResponse(response, contextFilePath),
+                    }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            context.logger.error(`Failed to rename persona: ${error}`);
+            return createErrorResult(`Failed to rename persona '${oldName}' to '${newName}': ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
-        return avoidPatterns;
+    }
+    static async handlePersonaNotFound(args, service, context) {
+        const availablePersonas = await service.listPersonas({}) || [];
+        // Always prompt for confirmation when persona doesn't exist
+        if (!args.confirmCreate) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            requiresConfirmation: true,
+                            action: 'createPersona',
+                            personaName: args.personaName,
+                            message: `Persona "${args.personaName}" doesn't exist. Would you like to create it?`,
+                            availablePersonas: availablePersonas.length > 0 ? availablePersonas : undefined,
+                            hint: 'To confirm creation, call the tool again with confirmCreate: true',
+                        }, null, 2),
+                    }],
+                isError: false,
+            };
+        }
+        // Create the persona
+        const profileString = createDefaultProfile(args.personaName, new Date().toISOString());
+        await service.createPersona({
+            personaName: args.personaName,
+            profile: profileString
+        });
+        // After creation, switch to the new persona
+        return AsTool.handleSwitchPersona({ ...args }, // confirmCreate is already true, no recursion issue
+        context);
     }
 }
 //# sourceMappingURL=as.tool.js.map