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

package/dist/services/repo-service.js

@@ -0,0 +1,1023 @@
+/**
+ * Repository Context Service
+ *
+ * Manages the tiny-brain section of the context file (CLAUDE.md, etc.)
+ * Responsible for formatting and storing repository analysis and agent usage.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { detectTechStackChanges } from '@magic-ingredients/tiny-brain-core';
+import { getRepoRoot } from '../utils/repo-utils.js';
+/**
+ * Service for managing repository context in the context file
+ * Handles the tiny-brain section with analysis and agent usage
+ */
+export class RepoService {
+    context;
+    static REPO_BLOCK_START = '## tiny-brain - start';
+    static REPO_BLOCK_END = '## tiny-brain - end';
+    static ANALYSIS_MARKER_PREFIX = '<!-- TB_ANALYSIS:';
+    static ANALYSIS_MARKER_SUFFIX = ' -->';
+    // New constants for subagent context protocol
+    static SUBAGENT_PROTOCOL_HEADER = '## Subagent Context Protocol';
+    static AGENT_USAGE_HEADER = '### When to Use Agents';
+    static REPO_CONTEXT_HEADER = '### Repository Context';
+    static USAGE_TEMPLATE_HEADER = '### Usage Template';
+    static EXAMPLE_HEADER = '### Example';
+    static ANALYSIS_IGNORE_PREFIX = '<!-- TB_ANALYSIS-IGNORE:';
+    static ANALYSIS_IGNORE_SUFFIX = ' -->';
+    static STATUS_IGNORE_PREFIX = '<!-- TB-STATUS-IGNORE:';
+    static STATUS_IGNORE_SUFFIX = ' -->';
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * Write the repository block to context file with phase-based agent structure
+     */
+    async writeRepoBlockWithPhases(analysis, agentResponse, contextFilePath = 'CLAUDE.md') {
+        const repoRoot = getRepoRoot();
+        const fullPath = path.join(repoRoot, contextFilePath);
+        this.context.logger.debug('[RepoService] Writing repo block with phases to context file:', {
+            repoRoot,
+            contextFilePath,
+            fullPath,
+            agentCount: agentResponse?.agents?.length || 0
+        });
+        // Build the complete repo block with phase-based formatting
+        const repoBlock = this.formatRepoBlockWithPhases(analysis, agentResponse);
+        // Read existing content
+        let existingContent = '';
+        try {
+            existingContent = await fs.readFile(fullPath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist, that's ok
+        }
+        // Update or append tiny-brain section
+        const startMarker = RepoService.REPO_BLOCK_START;
+        const endMarker = RepoService.REPO_BLOCK_END;
+        if (existingContent.includes(startMarker)) {
+            // Replace existing tiny-brain section
+            const startIndex = existingContent.indexOf(startMarker);
+            const endIndex = existingContent.indexOf(endMarker);
+            if (endIndex > -1) {
+                // Replace from start to end marker (inclusive)
+                const afterEnd = existingContent.substring(endIndex + endMarker.length);
+                existingContent = existingContent.substring(0, startIndex) +
+                    repoBlock +
+                    afterEnd;
+            }
+            else {
+                // No end marker found, replace to next section or end of file
+                const nextSectionIndex = existingContent.indexOf('\n## ', startIndex + 1);
+                if (nextSectionIndex > -1) {
+                    existingContent = existingContent.substring(0, startIndex) +
+                        repoBlock +
+                        existingContent.substring(nextSectionIndex);
+                }
+                else {
+                    existingContent = existingContent.substring(0, startIndex) + repoBlock;
+                }
+            }
+        }
+        else {
+            // Append tiny-brain section
+            existingContent = existingContent.trimEnd() + '\n\n' + repoBlock;
+        }
+        // Ensure directory exists and write file
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, existingContent, 'utf-8');
+        this.context.logger.info(`Updated repo block with ${agentResponse?.agents?.length || 0} agents in phase structure`);
+        // Return the formatted block (without the extra newline at the end)
+        return repoBlock.trimEnd();
+    }
+    /**
+     * Write the repository block to context file and return the formatted block (legacy compact format)
+     */
+    async writeRepoBlockToContextFile(analysis, agents, contextFilePath = 'CLAUDE.md') {
+        const repoRoot = getRepoRoot();
+        const fullPath = path.join(repoRoot, contextFilePath);
+        this.context.logger.debug('[RepoService] Writing repo block to context file:', {
+            repoRoot,
+            contextFilePath,
+            fullPath
+        });
+        // Build the complete repo block
+        const repoBlock = this.formatRepoBlock(analysis, agents);
+        // Read existing content
+        let existingContent = '';
+        try {
+            existingContent = await fs.readFile(fullPath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist, that's ok
+        }
+        // Update or append tiny-brain section
+        const startMarker = RepoService.REPO_BLOCK_START;
+        const endMarker = RepoService.REPO_BLOCK_END;
+        if (existingContent.includes(startMarker)) {
+            // Replace existing tiny-brain section
+            const startIndex = existingContent.indexOf(startMarker);
+            const endIndex = existingContent.indexOf(endMarker);
+            if (endIndex > -1) {
+                // Replace from start to end marker (inclusive)
+                const afterEnd = existingContent.substring(endIndex + endMarker.length);
+                existingContent = existingContent.substring(0, startIndex) +
+                    repoBlock +
+                    afterEnd;
+            }
+            else {
+                // No end marker found, replace to next section or end of file
+                const nextSectionIndex = existingContent.indexOf('\n## ', startIndex + 1);
+                if (nextSectionIndex > -1) {
+                    existingContent = existingContent.substring(0, startIndex) +
+                        repoBlock +
+                        existingContent.substring(nextSectionIndex);
+                }
+                else {
+                    existingContent = existingContent.substring(0, startIndex) + repoBlock;
+                }
+            }
+        }
+        else {
+            // Append tiny-brain section
+            existingContent = existingContent.trimEnd() + '\n\n' + repoBlock;
+        }
+        // Ensure directory exists and write file
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, existingContent, 'utf-8');
+        this.context.logger.info(`Updated repo block with ${agents.length} agents`);
+        // Return the formatted block (without the extra newline at the end)
+        return repoBlock.trimEnd();
+    }
+    /**
+     * Read the repository block from context file
+     */
+    async readRepoBlockFromContextFile(contextFilePath = 'CLAUDE.md') {
+        try {
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Find the tiny-brain section
+            const startMarker = RepoService.REPO_BLOCK_START;
+            const endMarker = RepoService.REPO_BLOCK_END;
+            const startIndex = content.indexOf(startMarker);
+            if (startIndex === -1) {
+                return null;
+            }
+            const endIndex = content.indexOf(endMarker, startIndex);
+            if (endIndex === -1) {
+                // No end marker, read to next section or end
+                const nextSectionIndex = content.indexOf('\n## ', startIndex + 1);
+                if (nextSectionIndex > -1) {
+                    return content.substring(startIndex, nextSectionIndex).trimEnd();
+                }
+                return content.substring(startIndex).trimEnd();
+            }
+            // Include the end marker
+            return content.substring(startIndex, endIndex + endMarker.length).trimEnd();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Format the repository block with phase-based agent structure
+     */
+    formatRepoBlockWithPhases(analysis, agentResponse) {
+        let block = `${RepoService.REPO_BLOCK_START}\n`;
+        block += `${RepoService.SUBAGENT_PROTOCOL_HEADER}\n\n`;
+        // When to use agents - phase-based format
+        block += `${RepoService.AGENT_USAGE_HEADER}\n\n`;
+        block += this.formatAgentsWithPhases(agentResponse);
+        // Repository context - YAML format
+        block += `${RepoService.REPO_CONTEXT_HEADER}\n`;
+        block += this.formatRepositoryContextYaml(analysis);
+        // Usage template
+        block += `\n${RepoService.USAGE_TEMPLATE_HEADER}\n\n`;
+        block += '```\n';
+        block += 'Repository Context: [paste the yaml above]\n\n';
+        block += 'AGENT: [choose from list above]\n';
+        block += 'TASK: [specific task description]\n';
+        block += 'CONSTRAINTS: [requirements/limitations]\n';
+        block += 'EXPECTED OUTPUT: [what you need back]\n';
+        block += '```\n';
+        // Example
+        block += `\n${RepoService.EXAMPLE_HEADER}\n`;
+        block += '```\n';
+        block += 'Repository Context: [repo context yaml]\n\n';
+        block += 'AGENT: component-developer\n';
+        block += 'TASK: Create a UserProfile component with avatar, name, and email\n';
+        block += 'CONSTRAINTS: Must be accessible, use TypeScript, follow TDD\n';
+        block += 'EXPECTED OUTPUT: Component file with tests and usage example\n';
+        block += '```\n';
+        // TB_ANALYSIS at the end with IGNORE suffix for clarity
+        block += `\n${RepoService.ANALYSIS_IGNORE_PREFIX}${JSON.stringify(analysis)}${RepoService.ANALYSIS_IGNORE_SUFFIX}\n`;
+        block += `${RepoService.REPO_BLOCK_END}\n`;
+        return block;
+    }
+    /**
+     * Format the complete repository block with subagent context protocol (legacy compact format)
+     */
+    formatRepoBlock(analysis, agents) {
+        let block = `${RepoService.REPO_BLOCK_START}\n`;
+        block += `${RepoService.SUBAGENT_PROTOCOL_HEADER}\n\n`;
+        // When to use agents - compact format
+        block += `${RepoService.AGENT_USAGE_HEADER}\n\n`;
+        block += this.formatAgentsCompact(agents);
+        // Repository context - YAML format
+        block += `${RepoService.REPO_CONTEXT_HEADER}\n`;
+        block += this.formatRepositoryContextYaml(analysis);
+        // Usage template
+        block += `\n${RepoService.USAGE_TEMPLATE_HEADER}\n\n`;
+        block += '```\n';
+        block += 'Repository Context: [paste the yaml above]\n\n';
+        block += 'AGENT: [choose from list above]\n';
+        block += 'TASK: [specific task description]\n';
+        block += 'CONSTRAINTS: [requirements/limitations]\n';
+        block += 'EXPECTED OUTPUT: [what you need back]\n';
+        block += '```\n';
+        // Example
+        block += `\n${RepoService.EXAMPLE_HEADER}\n`;
+        block += '```\n';
+        block += 'Repository Context: [repo context yaml]\n\n';
+        block += 'AGENT: component-developer\n';
+        block += 'TASK: Create a UserProfile component with avatar, name, and email\n';
+        block += 'CONSTRAINTS: Must be accessible, use TypeScript, follow TDD\n';
+        block += 'EXPECTED OUTPUT: Component file with tests and usage example\n';
+        block += '```\n';
+        // TB_ANALYSIS at the end with IGNORE suffix for clarity
+        block += `\n${RepoService.ANALYSIS_IGNORE_PREFIX}${JSON.stringify(analysis)}${RepoService.ANALYSIS_IGNORE_SUFFIX}\n`;
+        block += `${RepoService.REPO_BLOCK_END}\n`;
+        return block;
+    }
+    /**
+     * Parse the repository block from context file into structured data
+     */
+    async parseRepoBlock(contextFilePath = 'CLAUDE.md') {
+        const repoBlockMarkdown = await this.readRepoBlockFromContextFile(contextFilePath);
+        if (!repoBlockMarkdown)
+            return null;
+        // Extract JSON from comment
+        const analysisRegex = new RegExp(`${RepoService.ANALYSIS_MARKER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_MARKER_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+        const jsonMatch = repoBlockMarkdown.match(analysisRegex);
+        const rawAnalysis = jsonMatch ? JSON.parse(jsonMatch[1]) : null;
+        // Extract analysis section
+        const analysisMatch = repoBlockMarkdown.match(/### repo analysis\n([\s\S]*?)(?=\n###|\n##|$)/);
+        const analysis = analysisMatch ? analysisMatch[1].trim() : '';
+        // Extract documentation section (optional)
+        const docMatch = repoBlockMarkdown.match(/#### documentation\n([\s\S]*?)(?=\n###|\n##|$)/);
+        const documentation = docMatch ? docMatch[1].trim() : null;
+        // Extract agent usage section
+        const agentMatch = repoBlockMarkdown.match(/### agent usage\n([\s\S]*?)(?=\n##|$)/);
+        const agentUsage = agentMatch ? agentMatch[1].trim() : 'No agents available for this repository.';
+        return { rawAnalysis, analysis, documentation, agentUsage };
+    }
+    /**
+     * Format agents with phase-based structure
+     */
+    formatAgentsWithPhases(agentResponse) {
+        // Handle empty response
+        if (!agentResponse?.agentUsage?.phases || Object.keys(agentResponse.agentUsage.phases).length === 0) {
+            return 'No agents available for this repository.\n';
+        }
+        let output = '';
+        const phases = agentResponse.agentUsage.phases;
+        const phaseOrder = ['ideation', 'development', 'testing', 'operations'];
+        const phaseNames = {
+            ideation: 'Phase 1: Ideation',
+            development: 'Phase 2: Development',
+            testing: 'Phase 3: Testing & Quality',
+            operations: 'Phase 4: Operations & Analysis'
+        };
+        // Format each phase
+        phaseOrder.forEach((phaseKey) => {
+            const phase = phases[phaseKey];
+            if (!phase)
+                return;
+            output += `#### ${phaseNames[phaseKey]}\n`;
+            // List agents
+            if (phase.agents && phase.agents.length > 0) {
+                phase.agents.forEach((agentName) => {
+                    const agent = agentResponse.agents?.find((a) => a.name === agentName);
+                    if (agent) {
+                        output += `- \`${agent.name}\` - ${agent.details.description}\n`;
+                    }
+                    else {
+                        output += `- \`${agentName}\`\n`;
+                    }
+                });
+                output += '\n';
+            }
+            // Phase handoffs
+            if (phase.handoffs && phase.handoffs.length > 0) {
+                const phaseName = phaseNames[phaseKey] || phaseKey;
+                const phaseTitle = phaseName.includes(':') ? phaseName.split(':')[0] : phaseName;
+                output += `**${phaseTitle} Handoffs:**\n`;
+                phase.handoffs.forEach((handoff) => {
+                    if (typeof handoff === 'string') {
+                        // Handle string format: "from → to: description"
+                        output += `- \`${handoff.replace(' → ', '` → `').replace(': ', '`: ')}\n`;
+                    }
+                    else {
+                        // Handle object format
+                        output += `- \`${handoff.from}\` → \`${handoff.to}\``;
+                        if (handoff.description) {
+                            output += `: ${handoff.description}`;
+                        }
+                        output += '\n';
+                    }
+                });
+                output += '\n';
+            }
+        });
+        // Cross-phase handoffs
+        if (agentResponse.agentUsage.crossPhaseHandoffs && agentResponse.agentUsage.crossPhaseHandoffs.length > 0) {
+            output += '### Cross-Phase Handoffs\n';
+            agentResponse.agentUsage.crossPhaseHandoffs.forEach((handoff) => {
+                const fromPhaseName = phaseNames[handoff.from] || handoff.from;
+                const toPhaseName = phaseNames[handoff.to] || handoff.to;
+                const fromName = fromPhaseName.includes(':') ? fromPhaseName.split(':')[1]?.trim() : fromPhaseName;
+                const toName = toPhaseName.includes(':') ? toPhaseName.split(':')[1]?.trim() : toPhaseName;
+                output += `**${fromName.charAt(0).toUpperCase() + fromName.slice(1)} → ${toName.charAt(0).toUpperCase() + toName.slice(1)}:**\n`;
+                output += `- ${handoff.description}\n\n`;
+            });
+        }
+        // Prerequisites
+        if (agentResponse.agentUsage.prerequisites && Object.keys(agentResponse.agentUsage.prerequisites).length > 0) {
+            output += '### Agent Prerequisites\n';
+            Object.entries(agentResponse.agentUsage.prerequisites).forEach(([agent, prerequisites]) => {
+                // Prerequisites can be either a string or array of strings
+                if (Array.isArray(prerequisites)) {
+                    if (prerequisites.length > 0) {
+                        const formattedPrereqs = prerequisites.map(prereq => `\`${prereq}\``).join(', ');
+                        output += `- \`${agent}\`: ${formattedPrereqs}\n`;
+                    }
+                }
+                else if (typeof prerequisites === 'string' && prerequisites.trim()) {
+                    // Prerequisites is a string description - wrap agent names in backticks
+                    const formattedPrerequisites = prerequisites.replace(/([a-z-]+(?:-[a-z]+)*)/g, (match) => {
+                        // Only wrap strings that look like agent names (hyphenated words)
+                        if (match.includes('-') || ['system', 'feature', 'component', 'functional', 'tdd', 'refactoring', 'metrics', 'root'].some(word => match.includes(word))) {
+                            return `\`${match}\``;
+                        }
+                        return match;
+                    });
+                    output += `- \`${agent}\`: ${formattedPrerequisites}\n`;
+                }
+            });
+            output += '\n';
+        }
+        // Invocation template
+        if (agentResponse.agentUsage.invocationTemplate?.structure) {
+            output += '### Agent Invocation Template\n';
+            output += '```\n';
+            output += agentResponse.agentUsage.invocationTemplate.structure.replace(/\\n/g, '\n');
+            output += '\n```\n';
+        }
+        return output;
+    }
+    /**
+     * Format agents in compact style with categories
+     */
+    formatAgentsCompact(agents) {
+        const categories = {
+            'Planning & Architecture': [],
+            'Development': [],
+            'Testing & Quality': [],
+            'Operations & Analysis': []
+        };
+        agents.forEach(agent => {
+            const compactDesc = this.getCompactDescription(agent.description);
+            const line = `\`${agent.name}\` - ${compactDesc}`;
+            // Categorize based on keywords in name and description
+            const searchText = `${agent.name} ${agent.description}`.toLowerCase();
+            if (searchText.includes('architect') || searchText.includes('researcher') ||
+                searchText.includes('planner') || searchText.includes('design') ||
+                searchText.includes('prd') || searchText.includes('requirement')) {
+                categories['Planning & Architecture'].push(line);
+            }
+            else if (searchText.includes('test') || searchText.includes('validator') ||
+                searchText.includes('quality') || searchText.includes('refactor') ||
+                searchText.includes('tdd')) {
+                categories['Testing & Quality'].push(line);
+            }
+            else if (searchText.includes('metrics') || searchText.includes('analyst') ||
+                searchText.includes('monitor') || searchText.includes('observ') ||
+                searchText.includes('collector') || searchText.includes('root-cause')) {
+                categories['Operations & Analysis'].push(line);
+            }
+            else {
+                // Default to Development
+                categories['Development'].push(line);
+            }
+        });
+        // Build formatted output
+        let output = '';
+        for (const [category, agentList] of Object.entries(categories)) {
+            if (agentList.length > 0) {
+                output += `**${category}**\n`;
+                agentList.forEach(line => output += `- ${line}\n`);
+                output += '\n';
+            }
+        }
+        return output;
+    }
+    /**
+     * Get compact description by removing common phrases and truncating if needed
+     */
+    getCompactDescription(description) {
+        // Remove common prefixes and make concise
+        let compact = description
+            .replace(/^(A |An |The )/i, '')
+            .replace(/specialist (who|that) /gi, '')
+            .replace(/focused on /gi, '')
+            .replace(/development specialist /gi, '');
+        // Capitalize first letter
+        compact = compact.charAt(0).toUpperCase() + compact.slice(1);
+        // Truncate if too long (80 chars)
+        if (compact.length > 80) {
+            compact = compact.substring(0, 77) + '...';
+        }
+        return compact;
+    }
+    /**
+     * Format repository context as clean YAML
+     */
+    formatRepositoryContextYaml(analysis) {
+        let yaml = '```yaml\n';
+        yaml += `Languages: ${analysis.languages.join(', ')}\n`;
+        yaml += `Frameworks: ${analysis.frameworks.join(', ')}\n`;
+        yaml += `Build Tools: ${analysis.buildTools.join(', ')}\n`;
+        yaml += `Testing Tools: ${analysis.testingTools.join(', ')}\n`;
+        if (analysis.hasTests) {
+            yaml += `Tests: ${analysis.testFileCount} files (patterns: ${analysis.testPatterns.join(', ')})\n`;
+        }
+        if (analysis.isPolyglot) {
+            yaml += `Polyglot: Yes (primary: ${analysis.primaryLanguage})\n`;
+        }
+        yaml += `Documentation Pattern: ${analysis.documentationPattern}\n`;
+        // Always use absolute paths for documentation
+        const docLocations = analysis.documentationLocations?.map(loc => path.isAbsolute(loc) ? loc : path.join(process.cwd(), loc)) || [];
+        yaml += `Documentation Locations: ${docLocations.join(', ')}\n`;
+        yaml += '```\n';
+        return yaml;
+    }
+    /**
+     * Extract TB_ANALYSIS from content with new IGNORE format
+     */
+    extractTBAnalysis(content) {
+        const regex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+        const match = content.match(regex);
+        if (match && match[1]) {
+            try {
+                return JSON.parse(match[1]);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract TB-STATUS from content with backwards compatibility for TB_ANALYSIS-IGNORE
+     */
+    extractTBStatus(content) {
+        // First try TB-STATUS-IGNORE (new format)
+        const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+        const statusMatch = content.match(statusRegex);
+        if (statusMatch && statusMatch[1]) {
+            try {
+                return JSON.parse(statusMatch[1]);
+            }
+            catch {
+                return null;
+            }
+        }
+        // Fall back to TB_ANALYSIS-IGNORE (legacy format)
+        const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(.*?)${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+        const analysisMatch = content.match(analysisRegex);
+        if (analysisMatch && analysisMatch[1]) {
+            try {
+                const analysis = JSON.parse(analysisMatch[1]);
+                // Convert RepoAnalysis to TBStatus format (no additional fields for legacy)
+                return analysis;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Generate TB-STATUS-IGNORE format string with current timestamp
+     */
+    updateTBStatus(analysis, installedAgents) {
+        const tbStatus = {
+            ...analysis,
+            lastUpdated: new Date().toISOString(),
+            ...(installedAgents && { installedAgents })
+        };
+        return `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
+    }
+    /**
+     * Check if repository is initialized (has TB-STATUS-IGNORE or TB_ANALYSIS-IGNORE)
+     */
+    isRepoInitialized(content) {
+        const tbStatus = this.extractTBStatus(content);
+        return tbStatus !== null;
+    }
+    /**
+     * Check if we're in a repository context
+     */
+    isInRepository() {
+        try {
+            // This will throw if not in a repo
+            getRepoRoot();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if repository is initialized (has TB block in context file)
+     */
+    async isRepositoryInitialized() {
+        if (!this.isInRepository()) {
+            return false; // Not in repo, so not initialized
+        }
+        try {
+            const content = await this.readRepoBlockFromContextFile();
+            return content ? this.isRepoInitialized(content) : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Compare two tech stacks and return differences
+     */
+    compareTechStack(previousAnalysis, currentAnalysis) {
+        return detectTechStackChanges({
+            languages: previousAnalysis.languages || [],
+            frameworks: previousAnalysis.frameworks || [],
+            buildTools: previousAnalysis.buildTools || [],
+            testingTools: previousAnalysis.testingTools || []
+        }, {
+            languages: currentAnalysis.languages || [],
+            frameworks: currentAnalysis.frameworks || [],
+            buildTools: currentAnalysis.buildTools || [],
+            testingTools: currentAnalysis.testingTools || []
+        });
+    }
+    /**
+     * Migrate legacy TB_ANALYSIS-IGNORE format to new TB-STATUS-IGNORE format
+     */
+    migrateToNewFormat(existingContent, newAnalysis) {
+        // Generate new TB-STATUS-IGNORE format
+        const newStatusIgnore = this.updateTBStatus(newAnalysis);
+        // Replace TB_ANALYSIS-IGNORE with TB-STATUS-IGNORE
+        if (existingContent.includes(RepoService.ANALYSIS_IGNORE_PREFIX)) {
+            const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+            return existingContent.replace(analysisRegex, newStatusIgnore);
+        }
+        // Replace existing TB-STATUS-IGNORE with updated version
+        if (existingContent.includes(RepoService.STATUS_IGNORE_PREFIX)) {
+            const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+            return existingContent.replace(statusRegex, newStatusIgnore);
+        }
+        // No existing format found, return original content
+        return existingContent;
+    }
+    /**
+     * Update agent usage section in CLAUDE.md with phase-based structure
+     */
+    async updateAgentUsageSection(installedAgents, phaseStructure, contextFilePath = 'CLAUDE.md') {
+        try {
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            // Read existing content or create new
+            let existingContent = '';
+            try {
+                existingContent = await fs.readFile(fullPath, 'utf-8');
+            }
+            catch {
+                // File doesn't exist, create with just the tiny-brain section
+                existingContent = '';
+            }
+            // Generate the agent usage content
+            const agentUsageContent = this.formatPhaseBasedAgentUsage(installedAgents, phaseStructure);
+            // Update or create the tiny-brain section
+            const updatedContent = this.updateTinyBrainSection(existingContent, agentUsageContent);
+            // Ensure directory exists and write file
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, updatedContent, 'utf-8');
+            this.context.logger.info(`Updated ${contextFilePath} with ${installedAgents.length} agents in phase structure`);
+        }
+        catch (error) {
+            this.context.logger.error(`Failed to update agent usage section in ${contextFilePath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Generate phase structure from installed agents
+     */
+    generatePhaseStructure(installedAgents) {
+        const structure = {
+            phases: {},
+            crossPhaseHandoffs: [],
+            prerequisites: {}
+        };
+        // Agent categorization
+        const ideationAgents = [];
+        const developmentAgents = [];
+        const testingAgents = [];
+        const operationsAgents = [];
+        // Categorize agents
+        installedAgents.forEach(agent => {
+            const name = agent.name.toLowerCase();
+            if (name.includes('prd') || name.includes('researcher') ||
+                name.includes('architect') || name.includes('planner')) {
+                ideationAgents.push(agent.name);
+            }
+            else if (name.includes('test') || name.includes('validator') ||
+                name.includes('tdd') || name.includes('refactor')) {
+                testingAgents.push(agent.name);
+            }
+            else if (name.includes('metrics') || name.includes('analyst') ||
+                name.includes('collector') || name.includes('monitor')) {
+                operationsAgents.push(agent.name);
+            }
+            else {
+                // Default to development
+                developmentAgents.push(agent.name);
+            }
+        });
+        // Build phase structure
+        if (ideationAgents.length > 0) {
+            structure.phases.ideation = {
+                agents: ideationAgents,
+                handoffs: this.generatePhaseHandoffs(ideationAgents)
+            };
+        }
+        if (developmentAgents.length > 0) {
+            structure.phases.development = {
+                agents: developmentAgents,
+                handoffs: this.generatePhaseHandoffs(developmentAgents)
+            };
+        }
+        if (testingAgents.length > 0) {
+            structure.phases.testing = {
+                agents: testingAgents,
+                handoffs: this.generatePhaseHandoffs(testingAgents)
+            };
+        }
+        if (operationsAgents.length > 0) {
+            structure.phases.operations = {
+                agents: operationsAgents,
+                handoffs: this.generatePhaseHandoffs(operationsAgents)
+            };
+        }
+        // Generate cross-phase handoffs
+        structure.crossPhaseHandoffs = this.generateCrossPhaseHandoffs(structure.phases);
+        // Generate prerequisites
+        structure.prerequisites = this.generatePrerequisites(installedAgents);
+        return structure;
+    }
+    /**
+     * Create or update TB-STATUS-IGNORE with analysis and installed agents
+     */
+    async createOrUpdateTBStatus(analysis, installedAgents, contextFilePath = 'CLAUDE.md') {
+        try {
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            // Read existing content
+            let existingContent = '';
+            try {
+                existingContent = await fs.readFile(fullPath, 'utf-8');
+            }
+            catch {
+                // File doesn't exist
+            }
+            // Create TB status data
+            const tbStatus = {
+                ...analysis,
+                lastUpdated: new Date().toISOString(),
+                installedAgents
+            };
+            // Generate TB-STATUS-IGNORE format
+            const statusIgnore = `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
+            // Update the status in the content
+            let updatedContent = existingContent;
+            // Replace existing TB-STATUS-IGNORE or TB_ANALYSIS-IGNORE
+            if (existingContent.includes(RepoService.STATUS_IGNORE_PREFIX)) {
+                const statusRegex = new RegExp(`${RepoService.STATUS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.STATUS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+                updatedContent = existingContent.replace(statusRegex, statusIgnore);
+            }
+            else if (existingContent.includes(RepoService.ANALYSIS_IGNORE_PREFIX)) {
+                const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+                updatedContent = existingContent.replace(analysisRegex, statusIgnore);
+            }
+            else {
+                // Add to tiny-brain section or create it
+                updatedContent = this.addStatusToContent(existingContent, statusIgnore);
+            }
+            // Write updated content
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, updatedContent, 'utf-8');
+            this.context.logger.info(`Updated TB-STATUS-IGNORE with ${installedAgents.length} agents`);
+        }
+        catch (error) {
+            this.context.logger.error('Failed to create or update TB-STATUS-IGNORE:', error);
+            throw error;
+        }
+    }
+    /**
+     * Migrate legacy TB_ANALYSIS-IGNORE to TB-STATUS-IGNORE format
+     */
+    async migrateTBAnalysisToTBStatus(existingContent, installedAgents, contextFilePath = 'CLAUDE.md') {
+        try {
+            // Extract existing analysis data
+            const existingAnalysis = this.extractTBAnalysis(existingContent);
+            if (!existingAnalysis) {
+                this.context.logger.warn('No TB_ANALYSIS-IGNORE found to migrate');
+                return;
+            }
+            // Create TB status with preserved analysis data and new agents
+            const tbStatus = {
+                ...existingAnalysis,
+                lastUpdated: new Date().toISOString(),
+                installedAgents
+            };
+            // Generate new TB-STATUS-IGNORE
+            const statusIgnore = `${RepoService.STATUS_IGNORE_PREFIX}${JSON.stringify(tbStatus)}${RepoService.STATUS_IGNORE_SUFFIX}`;
+            // Replace TB_ANALYSIS-IGNORE with TB-STATUS-IGNORE
+            const analysisRegex = new RegExp(`${RepoService.ANALYSIS_IGNORE_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*?${RepoService.ANALYSIS_IGNORE_SUFFIX.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 's');
+            const updatedContent = existingContent.replace(analysisRegex, statusIgnore);
+            // Write migrated content
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            await fs.writeFile(fullPath, updatedContent, 'utf-8');
+            this.context.logger.info('Successfully migrated TB_ANALYSIS-IGNORE to TB-STATUS-IGNORE format');
+        }
+        catch (error) {
+            this.context.logger.error('Failed to migrate TB_ANALYSIS-IGNORE:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get TB status from CLAUDE.md with fallback to legacy format
+     */
+    async getTBStatus(contextFilePath = 'CLAUDE.md') {
+        try {
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Try to extract TB status using existing method
+            const tbStatus = this.extractTBStatus(content);
+            if (tbStatus && !tbStatus.installedAgents) {
+                // Legacy format detected, recommend migration
+                this.context.logger.info('Legacy TB_ANALYSIS-IGNORE format detected. Consider migrating to TB-STATUS-IGNORE.');
+            }
+            return tbStatus;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist
+                return null;
+            }
+            this.context.logger.warn('Failed to parse TB status:', error);
+            return null;
+        }
+    }
+    /**
+     * Update repository context YAML section with current analysis
+     */
+    async updateRepositoryContext(analysis, contextFilePath = 'CLAUDE.md') {
+        try {
+            const repoRoot = getRepoRoot();
+            const fullPath = path.join(repoRoot, contextFilePath);
+            // Read existing content
+            let existingContent = '';
+            try {
+                existingContent = await fs.readFile(fullPath, 'utf-8');
+            }
+            catch {
+                // File doesn't exist
+                return;
+            }
+            // Generate new YAML content
+            const newYamlContent = this.formatRepositoryContextYaml(analysis);
+            // Find and replace the Repository Context section
+            const contextHeaderRegex = /### Repository Context\n```yaml\n.*?\n```/s;
+            const updatedContent = existingContent.replace(contextHeaderRegex, `### Repository Context\n${newYamlContent}`);
+            // Write updated content
+            await fs.writeFile(fullPath, updatedContent, 'utf-8');
+            this.context.logger.info('Updated repository context YAML section');
+        }
+        catch (error) {
+            this.context.logger.error('Failed to update repository context:', error);
+            throw error;
+        }
+    }
+    /**
+     * Format phase-based agent usage content
+     */
+    formatPhaseBasedAgentUsage(installedAgents, phaseStructure) {
+        // Suppress unused parameter warning - installedAgents used implicitly through phaseStructure
+        void installedAgents;
+        let content = '### When to Use Agents\n\n';
+        const phaseNames = {
+            ideation: 'Phase 1: Ideation',
+            development: 'Phase 2: Development',
+            testing: 'Phase 3: Testing & Quality',
+            operations: 'Phase 4: Operations & Analysis'
+        };
+        // Generate phase sections
+        Object.entries(phaseStructure.phases).forEach(([phaseKey, phase]) => {
+            const phaseName = phaseNames[phaseKey] || phaseKey;
+            content += `#### ${phaseName}\n`;
+            // List agents
+            phase.agents.forEach(agentName => {
+                const description = this.getAgentDescription(agentName);
+                content += `- \`${agentName}\` - ${description}\n`;
+            });
+            // Add handoffs if any
+            if (phase.handoffs.length > 0) {
+                content += `\n**${phaseName.split(':')[0]} Handoffs:**\n`;
+                phase.handoffs.forEach(handoff => {
+                    content += `- ${handoff.replace(/(\w+)/g, '`$1`')}\n`;
+                });
+            }
+            content += '\n';
+        });
+        // Add cross-phase handoffs
+        if (phaseStructure.crossPhaseHandoffs.length > 0) {
+            content += '### Cross-Phase Handoffs\n';
+            phaseStructure.crossPhaseHandoffs.forEach(handoff => {
+                const fromPhase = phaseNames[handoff.from] || handoff.from;
+                const toPhase = phaseNames[handoff.to] || handoff.to;
+                content += `**${fromPhase.split(':')[1]?.trim()} → ${toPhase.split(':')[1]?.trim()}:**\n`;
+                content += `- ${handoff.description}\n\n`;
+            });
+        }
+        // Add prerequisites
+        if (Object.keys(phaseStructure.prerequisites).length > 0) {
+            content += '### Agent Prerequisites\n';
+            Object.entries(phaseStructure.prerequisites).forEach(([agent, prereqs]) => {
+                if (Array.isArray(prereqs)) {
+                    const formattedPrereqs = prereqs.map(p => `\`${p}\``).join(', ');
+                    content += `- \`${agent}\`: ${formattedPrereqs}\n`;
+                }
+                else if (typeof prereqs === 'string') {
+                    content += `- \`${agent}\`: ${prereqs}\n`;
+                }
+            });
+        }
+        return content;
+    }
+    /**
+     * Update tiny-brain section in content with new agent usage
+     */
+    updateTinyBrainSection(existingContent, agentUsageContent) {
+        const startMarker = RepoService.REPO_BLOCK_START;
+        const endMarker = RepoService.REPO_BLOCK_END;
+        if (existingContent.includes(startMarker)) {
+            // Replace existing tiny-brain section
+            const startIndex = existingContent.indexOf(startMarker);
+            const endIndex = existingContent.indexOf(endMarker);
+            if (endIndex > -1) {
+                // Replace content between markers
+                const beforeSection = existingContent.substring(0, startIndex);
+                const afterSection = existingContent.substring(endIndex + endMarker.length);
+                return beforeSection + this.buildTinyBrainSection(agentUsageContent) + afterSection;
+            }
+        }
+        // Add new tiny-brain section
+        return existingContent.trimEnd() + '\n\n' + this.buildTinyBrainSection(agentUsageContent);
+    }
+    /**
+     * Build complete tiny-brain section
+     */
+    buildTinyBrainSection(agentUsageContent) {
+        return `${RepoService.REPO_BLOCK_START}\n` +
+            `${RepoService.SUBAGENT_PROTOCOL_HEADER}\n\n` +
+            agentUsageContent + '\n' +
+            `${RepoService.REPO_BLOCK_END}`;
+    }
+    /**
+     * Add TB status to content (create tiny-brain section if needed)
+     */
+    addStatusToContent(existingContent, statusIgnore) {
+        const startMarker = RepoService.REPO_BLOCK_START;
+        const endMarker = RepoService.REPO_BLOCK_END;
+        if (existingContent.includes(startMarker) && existingContent.includes(endMarker)) {
+            // Add before end marker
+            const endIndex = existingContent.indexOf(endMarker);
+            return existingContent.substring(0, endIndex) +
+                statusIgnore + '\n' +
+                existingContent.substring(endIndex);
+        }
+        else {
+            // Create minimal tiny-brain section
+            return existingContent.trimEnd() + '\n\n' +
+                `${startMarker}\n${statusIgnore}\n${endMarker}\n`;
+        }
+    }
+    /**
+     * Generate handoffs for agents within a phase
+     */
+    generatePhaseHandoffs(agents) {
+        const handoffs = [];
+        // Generate common handoff patterns
+        if (agents.includes('prd-researcher') && agents.includes('system-architect')) {
+            handoffs.push('prd-researcher → system-architect: Requirements analysis to system design');
+        }
+        if (agents.includes('system-architect') && agents.includes('backend-architect')) {
+            handoffs.push('system-architect → backend-architect: System design to backend architecture');
+        }
+        if (agents.includes('feature-developer') && agents.includes('component-developer')) {
+            handoffs.push('feature-developer → component-developer: Feature specs to UI implementation');
+        }
+        if (agents.includes('feature-developer') && agents.includes('typescript-developer')) {
+            handoffs.push('feature-developer → typescript-developer: Feature specs to type-safe implementation');
+        }
+        return handoffs;
+    }
+    /**
+     * Generate cross-phase handoffs based on available phases
+     */
+    generateCrossPhaseHandoffs(phases) {
+        const handoffs = [];
+        if (phases.ideation && phases.development) {
+            handoffs.push({
+                from: 'ideation',
+                to: 'development',
+                description: 'Architecture outputs → Development agents'
+            });
+        }
+        if (phases.development && phases.testing) {
+            handoffs.push({
+                from: 'development',
+                to: 'testing',
+                description: 'Implementation outputs → Testing agents'
+            });
+        }
+        if (phases.testing && phases.operations) {
+            handoffs.push({
+                from: 'testing',
+                to: 'operations',
+                description: 'Quality metrics → Operational monitoring'
+            });
+        }
+        return handoffs;
+    }
+    /**
+     * Generate prerequisites for agents
+     */
+    generatePrerequisites(installedAgents) {
+        const prerequisites = {};
+        const agentNames = installedAgents.map(a => a.name);
+        agentNames.forEach(agent => {
+            if (agent === 'feature-developer' && agentNames.includes('system-architect')) {
+                prerequisites[agent] = ['system-architect'];
+            }
+            if (agent === 'component-developer' && agentNames.includes('system-architect')) {
+                prerequisites[agent] = ['system-architect'];
+            }
+            if (agent === 'typescript-developer' &&
+                (agentNames.includes('backend-architect') || agentNames.includes('system-architect'))) {
+                prerequisites[agent] = agentNames.includes('backend-architect') ?
+                    ['backend-architect', 'system-architect'] : ['system-architect'];
+            }
+            if (agent === 'tdd-validator' && agentNames.some(a => a.includes('developer'))) {
+                prerequisites[agent] = agentNames.filter(a => a.includes('developer'));
+            }
+        });
+        return prerequisites;
+    }
+    /**
+     * Get description for an agent (placeholder - could be enhanced)
+     */
+    getAgentDescription(agentName) {
+        const descriptions = {
+            'prd-researcher': 'Research and analyze Product Requirements Documents to generate comprehensive technical tasks and implementation strategies',
+            'system-architect': 'Design comprehensive system architectures that integrate frontend, backend, and infrastructure components',
+            'backend-architect': 'Design and architect reliable backend systems with focus on data integrity, security, and fault tolerance',
+            'feature-developer': 'Feature implementation specialist who transforms requirements into working functionality',
+            'component-developer': 'UI component development specialist focused on building reusable, accessible, and well-tested components',
+            'typescript-developer': 'TypeScript development specialist focused on type-safe, maintainable code following modern JavaScript/TypeScript best practices',
+            'tdd-validator': 'Test-Driven Development methodology validator ensuring rigorous TDD compliance and quality gates',
+            'functional-tester': 'Functional testing specialist who validates software functionality against requirements',
+            'refactoring-expert': 'Code refactoring specialist focused on improving code quality, maintainability, and performance without changing functionality',
+            'metrics-collector': 'Metrics and observability specialist who gathers, analyzes, and reports on system and business metrics',
+            'root-cause-analyst': 'Incident investigation specialist who diagnoses system issues and identifies root causes'
+        };
+        return descriptions[agentName] || `${agentName.replace(/-/g, ' ')} specialist`;
+    }
+}
+//# sourceMappingURL=repo-service.js.map