@magic-ingredients/tiny-brain-local 0.18.1 → 0.19.1

package/dist/services/repo-service.d.ts

@@ -58,6 +58,11 @@ export declare class RepoService {
      * - Operational Tracking Directory (when SDD enabled)
      */
     writeWorkflowSections(options?: WriteWorkflowSectionsOptions): Promise<void>;
+    /**
+     * Format the Repository Context section
+     * When agentic coding is enabled, includes a mandatory agent delegation section
+     */
+    private formatRepoContextSection;
     /**
      * Format the Commit Message Format section
      */

package/dist/services/repo-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repo-service.d.ts","sourceRoot":"","sources":["../../src/services/repo-service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAIlE,MAAM,WAAW,4BAA4B;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,qBAAa,WAAW;IAMV,OAAO,CAAC,OAAO;IAL3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IACnE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAyB;IAE/D,OAAO,CAAC,aAAa,CAAgB;gBAEjB,OAAO,EAAE,cAAc;IAS3C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACG,4BAA4B,CAChC,eAAe,GAAE,MAAoB,GACpC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAmCzB;;;;OAIG;IACH,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvD;;OAEG;IACH,cAAc,IAAI,OAAO;IAUzB;;;OAGG;IACG,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAcjD;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAa5B;;;;;;;;OAQG;IACG,qBAAqB,CAAC,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,IAAI,CAAC;IAwFtF;;OAEG;IACH,OAAO,CAAC,0BAA0B;IA4GlC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoChC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAwErC;;OAEG;IACH,OAAO,CAAC,gCAAgC;CAqCzC"}
+{"version":3,"file":"repo-service.d.ts","sourceRoot":"","sources":["../../src/services/repo-service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAIlE,MAAM,WAAW,4BAA4B;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,qBAAa,WAAW;IAMV,OAAO,CAAC,OAAO;IAL3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IACnE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAyB;IAE/D,OAAO,CAAC,aAAa,CAAgB;gBAEjB,OAAO,EAAE,cAAc;IAS3C;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;OAEG;IACG,4BAA4B,CAChC,eAAe,GAAE,MAAoB,GACpC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAmCzB;;;;OAIG;IACH,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvD;;OAEG;IACH,cAAc,IAAI,OAAO;IAUzB;;;OAGG;IACG,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAcjD;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAa5B;;;;;;;;OAQG;IACG,qBAAqB,CAAC,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,IAAI,CAAC;IA6FtF;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAyBhC;;OAEG;IACH,OAAO,CAAC,0BAA0B;IA4GlC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoChC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAwErC;;OAEG;IACH,OAAO,CAAC,gCAAgC;CAyCzC"}

package/dist/services/repo-service.js

@@ -147,12 +147,15 @@ export class RepoService {
         // Check config flags
         const enableSDD = await this.configService.isSDDEnabled();
         const enableTDD = await this.configService.isTDDEnabled();
+        const enableAgentic = await this.configService.isAgenticCodingEnabled();
         // If nothing is enabled, don't write anything
         if (!enableSDD && !enableTDD) {
             return;
         }
         // Build the workflow sections content
         let workflowContent = '';
+        // Repository Context (always when workflow sections are enabled)
+        workflowContent += this.formatRepoContextSection(enableAgentic);
         // Commit Message Format (when SDD enabled)
         if (enableSDD) {
             workflowContent += this.formatCommitMessageSection();
@@ -169,8 +172,9 @@ export class RepoService {
         if (enableSDD) {
             workflowContent += this.formatOperationalTrackingSection();
         }
-        // Build the complete tiny-brain block
-        const repoBlock = `${RepoService.REPO_BLOCK_START}\n\n${workflowContent}${RepoService.REPO_BLOCK_END}\n`;
+        // Build the complete tiny-brain block with version frontmatter
+        const version = this.getAnalysisVersion();
+        const repoBlock = `${RepoService.REPO_BLOCK_START}\n---\nversion: ${version}\n---\n\n${workflowContent}${RepoService.REPO_BLOCK_END}\n`;
         // Get full path
         const repoRoot = getRepoRoot();
         const fullPath = path.join(repoRoot, contextPath);
@@ -218,6 +222,32 @@ export class RepoService {
         await fs.writeFile(fullPath, existingContent, 'utf-8');
         this.context.logger.info(`Updated workflow sections in ${contextPath}`);
     }
+    /**
+     * Format the Repository Context section
+     * When agentic coding is enabled, includes a mandatory agent delegation section
+     */
+    formatRepoContextSection(enableAgenticCoding) {
+        let content = `## Repository Context
+
+Before starting work, read \`.tiny-brain/analysis.json\` for the detected tech stack, test patterns, and documentation locations.
+
+`;
+        if (enableAgenticCoding) {
+            content += `## Agent Delegation (MANDATORY)
+
+IMPORTANT: You MUST delegate implementation work to specialized agents using the Task tool. Do NOT write production code or tests directly.
+
+When the user asks you to implement a feature, fix a bug, or refactor code:
+1. Use the Task tool with \`subagent_type="tiny-brain:developer"\`
+2. Provide the full task context in the prompt
+3. Let the agent handle the TDD workflow (red/green/refactor)
+
+Only skip delegation for trivial tasks (single-line fixes, config changes).
+
+`;
+        }
+        return content;
+    }
     /**
      * Format the Commit Message Format section
      */
@@ -450,6 +480,10 @@ The \`.tiny-brain/\` directory stores operational tracking data separate from do
 
 \`\`\`
 .tiny-brain/
+├── analysis.json       # Detected tech stack and repo analysis
+├── tech/               # Technology-specific context files
+│   ├── config.json     # Tech context mode configuration
+│   └── {name}.md       # One file per detected technology
 ├── progress/           # PRD progress tracking
 │   └── {prd-id}.json   # One file per PRD
 └── fixes/              # Fix progress tracking

package/dist/tools/persona/as.tool.d.ts

@@ -37,6 +37,10 @@ export declare class AsTool {
      * Check if agents are installed by checking the platform-specific agents directory
      */
     private static checkHasAgents;
+    /**
+     * Resolve feature flags from ConfigService
+     */
+    private static resolveFeatureFlags;
     /**
      * Build persona response data structure
      */

package/dist/tools/persona/as.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"as.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/persona/as.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAWrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAqCrE;;;;;;;;;GASG;AACH,qBAAa,MAAM;IACjB,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAqDnC;;OAEG;WACU,OAAO,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA4BvF;;OAEG;mBACkB,wBAAwB;IAmE7C;;OAEG;mBACkB,mBAAmB;IA2ExC;;OAEG;mBACkB,oBAAoB;IAmGzC;;OAEG;mBACkB,eAAe;IAsBpC;;OAEG;mBACkB,cAAc;IAWnC;;OAEG;mBACkB,aAAa;IA6DlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA8H7B;;OAEG;mBACkB,mBAAmB;mBAyDnB,qBAAqB;CAsC3C"}
+{"version":3,"file":"as.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/persona/as.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACrF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAYrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAyCrE;;;;;;;;;GASG;AACH,qBAAa,MAAM;IACjB,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAqDnC;;OAEG;WACU,OAAO,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IA4BvF;;OAEG;mBACkB,wBAAwB;IAsE7C;;OAEG;mBACkB,mBAAmB;IA8ExC;;OAEG;mBACkB,oBAAoB;IAsGzC;;OAEG;mBACkB,eAAe;IAsBpC;;OAEG;mBACkB,cAAc;IAWnC;;OAEG;mBACkB,mBAAmB;IAexC;;OAEG;mBACkB,aAAa;IA6DlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA8H7B;;OAEG;mBACkB,mBAAmB;mBA4DnB,qBAAqB;CAsC3C"}

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

@@ -1,12 +1,9 @@
 import { z } from 'zod';
 import { createErrorResult } from '../index.js';
-import { createDefaultProfile, PlanningService, RulesService, LibraryClient, parsePersonaMarkdown } from '@magic-ingredients/tiny-brain-core';
+import { createDefaultProfile, PlanningService, RulesService, LibraryClient, ConfigService, 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';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getRepoRoot } from '../../utils/repo-utils.js';
 const AsArgsSchema = z.object({
     personaName: z.string().optional(),
     confirmCreate: z.boolean().optional(),
@@ -147,11 +144,14 @@ export class AsTool {
         const formatter = agentService.getDefaultFormatter();
         const contextFilePath = formatter.getRepoContextFilePath();
         const response = await AsTool.buildResponse(context, parsedPersona, contextFilePath);
-        const hasAgents = await AsTool.checkHasAgents(context, contextFilePath);
+        const [hasAgents, featureFlags] = await Promise.all([
+            AsTool.checkHasAgents(context, contextFilePath),
+            AsTool.resolveFeatureFlags(context),
+        ]);
         return {
             content: [{
                     type: 'text',
-                    text: AsTool.formatResponse(response, contextFilePath, hasAgents),
+                    text: AsTool.formatResponse(response, contextFilePath, hasAgents, featureFlags, context.libraryAuth),
                 }],
             isError: false,
         };
@@ -201,11 +201,14 @@ export class AsTool {
             // Activate persona and return response with updated context
             const updatedContext = await AsTool.activatePersona(personaName, profile, context);
             const response = await AsTool.buildResponse(updatedContext, parsedPersona, contextFilePath);
-            const hasAgents = await AsTool.checkHasAgents(updatedContext, contextFilePath);
+            const [hasAgents, featureFlags] = await Promise.all([
+                AsTool.checkHasAgents(updatedContext, contextFilePath),
+                AsTool.resolveFeatureFlags(updatedContext),
+            ]);
             return {
                 content: [{
                         type: 'text',
-                        text: AsTool.formatResponse(response, contextFilePath, hasAgents),
+                        text: AsTool.formatResponse(response, contextFilePath, hasAgents, featureFlags, updatedContext.libraryAuth),
                     }],
                 isError: false,
             };
@@ -280,11 +283,14 @@ export class AsTool {
             const contextFilePath = formatter?.getRepoContextFilePath();
             // Step 8: Build and return response
             const response = await AsTool.buildResponse(updatedContext, parsedPersona, contextFilePath);
-            const hasAgents = await AsTool.checkHasAgents(updatedContext, contextFilePath);
+            const [hasAgents, featureFlags] = await Promise.all([
+                AsTool.checkHasAgents(updatedContext, contextFilePath),
+                AsTool.resolveFeatureFlags(updatedContext),
+            ]);
             return {
                 content: [{
                         type: 'text',
-                        text: AsTool.formatResponse(response, contextFilePath, hasAgents) + needsInitMessage,
+                        text: AsTool.formatResponse(response, contextFilePath, hasAgents, featureFlags, updatedContext.libraryAuth) + needsInitMessage,
                     }],
                 isError: false,
             };
@@ -327,6 +333,24 @@ export class AsTool {
             return false;
         }
     }
+    /**
+     * Resolve feature flags from ConfigService
+     */
+    static async resolveFeatureFlags(context) {
+        try {
+            const configService = new ConfigService(context);
+            const [sddEnabled, tddEnabled, adrEnabled, agenticCodingEnabled] = await Promise.all([
+                configService.isSDDEnabled(),
+                configService.isTDDEnabled(),
+                configService.isADREnabled(),
+                configService.isAgenticCodingEnabled(),
+            ]);
+            return { sddEnabled, tddEnabled, adrEnabled, agenticCodingEnabled };
+        }
+        catch {
+            return { sddEnabled: false, tddEnabled: false, adrEnabled: false, agenticCodingEnabled: false };
+        }
+    }
     /**
      * Build persona response data structure
      */
@@ -385,7 +409,7 @@ export class AsTool {
     /**
      * Format the persona response as human-readable markdown with enforced workflow
      */
-    static formatResponse(response, contextFilePath, hasAgents) {
+    static formatResponse(response, contextFilePath, hasAgents, featureFlags, libraryAuth) {
         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`;
@@ -461,33 +485,32 @@ export class AsTool {
             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 += `    🧠 tiny brain\n\n`;
             formatted += `    ✅ Received context for persona\n`;
             formatted += `    ✅ Re-read ${contextFilePath}\n`;
-            // Check for PRD and ADR directories and add checklist items (indented by 2 spaces)
-            try {
-                const repoRoot = getRepoRoot();
-                const hasPRD = existsSync(join(repoRoot, 'docs', 'prd'));
-                const hasADR = existsSync(join(repoRoot, 'docs', 'adr'));
-                if (hasPRD) {
-                    formatted += `      ✅ Enabled Spec Driven Design workflow with Test Driven Development\n`;
-                }
-                if (hasADR) {
-                    formatted += `      ✅ Enabled Architecture Decision Records\n`;
-                }
+            if (featureFlags?.sddEnabled) {
+                formatted += `    ✅ Enabled Spec Driven Design workflow with Test Driven Development\n`;
+            }
+            if (featureFlags?.adrEnabled) {
+                formatted += `    ✅ Enabled Architecture Decision Records\n`;
+            }
+            if (featureFlags?.agenticCodingEnabled) {
+                formatted += `    ✅ Enabled agentic coding\n`;
             }
-            catch {
-                // Not in a repo, skip PRD/ADR checklist items
+            if (libraryAuth?.token) {
+                formatted += `    🔑 Connected to Tiny Brain Remote\n`;
+            }
+            if (libraryAuth?.hasLlmApiKey) {
+                formatted += `    🔑 LLM API key configured\n`;
             }
             // Only show pre-flight and agent-first workflow if agents are installed
             if (hasAgents) {
                 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`;
+            formatted += `I've switched to your **${response.PERSONA.name}** persona.\n\n`;
+            formatted += `🧠 Dashboard available at: [http://localhost:8765](http://localhost:8765)\n`;
         }
         else {
             // Add persona switch confirmation message when no context file
@@ -524,11 +547,14 @@ export class AsTool {
             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);
-            const hasAgents = await AsTool.checkHasAgents(updatedContext, contextFilePath);
+            const [hasAgents, featureFlags] = await Promise.all([
+                AsTool.checkHasAgents(updatedContext, contextFilePath),
+                AsTool.resolveFeatureFlags(updatedContext),
+            ]);
             return {
                 content: [{
                         type: 'text',
-                        text: AsTool.formatResponse(response, contextFilePath, hasAgents),
+                        text: AsTool.formatResponse(response, contextFilePath, hasAgents, featureFlags, updatedContext.libraryAuth),
                     }],
                 isError: false,
             };

package/dist/tools/quality/quality.tool.d.ts

@@ -16,5 +16,12 @@ export declare class QualityTool {
     private static handleSave;
     private static handleHistory;
     private static handleDetails;
+    private static handleCompare;
+    private static handlePlan;
+    private static handlePlanDetails;
+    private static handleDetectAnalyzers;
+    private static handleRunAnalyzers;
+    private static handleAssembleRun;
+    private static handleMergeResults;
 }
 //# sourceMappingURL=quality.tool.d.ts.map

package/dist/tools/quality/quality.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quality.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/quality/quality.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAiCrE;;GAEG;AACH,qBAAa,WAAW;IACtB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WA4EtB,OAAO,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC;mBAgCD,UAAU;mBAqCV,aAAa;mBA2Bb,aAAa;CA0EnC"}
+{"version":3,"file":"quality.tool.d.ts","sourceRoot":"","sources":["../../../src/tools/quality/quality.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAA0C,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAyDrE;;GAEG;AACH,qBAAa,WAAW;IACtB,MAAM,CAAC,iBAAiB,IAAI,OAAO;WA+KtB,OAAO,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,UAAU,CAAC;mBA8CD,UAAU;mBAqCV,aAAa;mBA2Bb,aAAa;mBA2Eb,aAAa;mBAsEb,UAAU;mBA0CV,iBAAiB;mBAgEjB,qBAAqB;mBA6BrB,kBAAkB;mBA+ClB,iBAAiB;IA8CtC,OAAO,CAAC,MAAM,CAAC,kBAAkB;CAoBlC"}

package/dist/tools/quality/quality.tool.js

@@ -5,13 +5,18 @@
  * Analysis is performed by agents; this tool only handles persistence.
  */
 import { z } from 'zod';
+import { promises as fs } from 'fs';
+import path from 'path';
 import { createSuccessResult, createErrorResult } from '../index.js';
-import { QualityService, QualityIssueSchema, SaveQualityRunInputSchema, } from '@magic-ingredients/tiny-brain-core';
+import { QualityService, AnalyzerDetectionService, AnalyzerExecutorService, AssemblyService, mergeResults, QualityIssueSchema, SaveQualityRunInputSchema, generateRunId, runIdToPath, } from '@magic-ingredients/tiny-brain-core';
 /**
  * Zod schema for QualityTool arguments
  */
 const QualityArgsSchema = z.object({
-    operation: z.enum(['save', 'history', 'details']),
+    operation: z.enum([
+        'save', 'history', 'details', 'compare', 'plan', 'plan-details',
+        'detect-analyzers', 'run-analyzers', 'merge-results', 'assemble-run',
+    ]),
     // For 'save' operation
     score: z.number().min(0).max(100).optional(),
     grade: z.enum(['A', 'B', 'C', 'D', 'F']).optional(),
@@ -28,6 +33,17 @@ const QualityArgsSchema = z.object({
     limit: z.number().min(1).optional(),
     // For 'details' operation
     runId: z.string().optional(),
+    // For 'compare' operation
+    baseRunId: z.string().optional(),
+    targetRunId: z.string().optional(),
+    // For 'plan' operation
+    sourceRunId: z.string().optional(),
+    targetGrade: z.string().optional(),
+    // For 'plan-details' operation
+    planId: z.string().optional(),
+    // For 'merge-results' operation
+    analyzerIssues: z.array(QualityIssueSchema).optional(),
+    llmIssues: z.array(QualityIssueSchema).optional(),
 });
 /**
  * MCP Tool for quality analysis persistence
@@ -44,18 +60,29 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
   • save: Persist a quality run to docs/quality/runs/
   • history: List previous quality runs with summary data
   • details: Get full details for a specific run by ID
+  • compare: Compare two runs to see new, resolved, and persistent issues
+  • plan: Generate a Quality Improvement Plan from a saved run
+  • plan-details: Retrieve a saved Quality Improvement Plan by ID
+  • detect-analyzers: Scan repo for configured static analyzers
+  • run-analyzers: Execute detected analyzers and return normalized issues
+  • merge-results: Merge analyzer + LLM issues with deduplication
+  • assemble-run: Read all intermediate files, merge, score, and save final report
 
 💡 WORKFLOW:
   1. Quality-coordinator agent performs analysis
   2. Agent calls quality save with score, grade, issues, recommendations
   3. Results stored as markdown in docs/quality/runs/YYYY-MM-DD-quality.md
-  4. Use history/details to retrieve past runs`,
+  4. Use history/details to retrieve past runs
+  5. Use plan to generate an improvement roadmap from a run`,
             inputSchema: {
                 type: 'object',
                 properties: {
                     operation: {
                         type: 'string',
-                        enum: ['save', 'history', 'details'],
+                        enum: [
+                            'save', 'history', 'details', 'compare', 'plan', 'plan-details',
+                            'detect-analyzers', 'run-analyzers', 'merge-results', 'assemble-run',
+                        ],
                         description: 'The quality operation to perform',
                     },
                     // For 'save' operation
@@ -80,6 +107,42 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
                                 line: { type: 'number' },
                                 message: { type: 'string' },
                                 suggestion: { type: 'string' },
+                                effort: {
+                                    type: 'string',
+                                    enum: ['trivial', 'small', 'medium', 'large', 'epic'],
+                                    description: 'Estimated effort to remediate',
+                                },
+                                impact: {
+                                    type: 'string',
+                                    enum: ['critical', 'high', 'medium', 'low'],
+                                    description: 'Impact level if this issue is not addressed',
+                                },
+                                theme: {
+                                    type: 'string',
+                                    description: 'Thematic grouping tag (e.g., "type-safety", "auth-hardening")',
+                                },
+                                evidence: {
+                                    type: 'string',
+                                    description: 'Code snippet or evidence showing the problem',
+                                },
+                                relatedIssues: {
+                                    type: 'array',
+                                    items: { type: 'number' },
+                                    description: 'Indices of related issues in the same run',
+                                },
+                                references: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'External references such as CWE or OWASP identifiers',
+                                },
+                                scoreImpact: {
+                                    type: 'number',
+                                    description: 'Points that would be gained if this issue were fixed',
+                                },
+                                effortHours: {
+                                    type: 'number',
+                                    description: 'Estimated hours to remediate',
+                                },
                             },
                             required: ['category', 'severity', 'file', 'message'],
                         },
@@ -103,6 +166,58 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
                         type: 'string',
                         description: 'Run ID to get details for (required for details)',
                     },
+                    // For 'compare' operation
+                    baseRunId: {
+                        type: 'string',
+                        description: 'Base run ID for comparison (required for compare)',
+                    },
+                    targetRunId: {
+                        type: 'string',
+                        description: 'Target run ID for comparison (required for compare)',
+                    },
+                    // For 'plan' operation
+                    sourceRunId: {
+                        type: 'string',
+                        description: 'Source run ID to generate improvement plan from (required for plan)',
+                    },
+                    targetGrade: {
+                        type: 'string',
+                        description: 'Target grade to aim for in the improvement plan (optional for plan)',
+                    },
+                    // For 'plan-details' operation
+                    planId: {
+                        type: 'string',
+                        description: 'Plan ID to retrieve details for (required for plan-details)',
+                    },
+                    // For 'merge-results' operation
+                    analyzerIssues: {
+                        type: 'array',
+                        description: 'Array of analyzer issues (required for merge-results)',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                category: { type: 'string' },
+                                severity: { type: 'string' },
+                                file: { type: 'string' },
+                                message: { type: 'string' },
+                            },
+                            required: ['category', 'severity', 'file', 'message'],
+                        },
+                    },
+                    llmIssues: {
+                        type: 'array',
+                        description: 'Array of LLM investigation issues (required for merge-results)',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                category: { type: 'string' },
+                                severity: { type: 'string' },
+                                file: { type: 'string' },
+                                message: { type: 'string' },
+                            },
+                            required: ['category', 'severity', 'file', 'message'],
+                        },
+                    },
                 },
                 required: ['operation'],
             },
@@ -123,6 +238,20 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
                     return await QualityTool.handleHistory(validatedArgs, service);
                 case 'details':
                     return await QualityTool.handleDetails(validatedArgs, service);
+                case 'compare':
+                    return await QualityTool.handleCompare(validatedArgs, service);
+                case 'plan':
+                    return await QualityTool.handlePlan(validatedArgs, service);
+                case 'plan-details':
+                    return await QualityTool.handlePlanDetails(validatedArgs, context.repositoryRoot);
+                case 'detect-analyzers':
+                    return await QualityTool.handleDetectAnalyzers(context.repositoryRoot);
+                case 'run-analyzers':
+                    return await QualityTool.handleRunAnalyzers(context.repositoryRoot);
+                case 'merge-results':
+                    return QualityTool.handleMergeResults(validatedArgs);
+                case 'assemble-run':
+                    return await QualityTool.handleAssembleRun(validatedArgs, context.repositoryRoot);
                 default:
                     return createErrorResult(`Unknown operation: ${validatedArgs.operation}`);
             }
@@ -243,4 +372,245 @@ Persists and retrieves quality analysis results. Analysis is performed by agents
         }
         return createSuccessResult(lines.join('\n'));
     }
+    static async handleCompare(args, service) {
+        if (!args.baseRunId) {
+            return createErrorResult('baseRunId is required for compare operation');
+        }
+        if (!args.targetRunId) {
+            return createErrorResult('targetRunId is required for compare operation');
+        }
+        const comparison = await service.compareRuns(args.baseRunId, args.targetRunId);
+        if (!comparison) {
+            return createErrorResult(`One or both runs not found: ${args.baseRunId}, ${args.targetRunId}`);
+        }
+        const deltaSign = comparison.scoreDelta >= 0 ? '+' : '';
+        const lines = [
+            `📊 Run Comparison: ${comparison.baseRunId} → ${comparison.targetRunId}`,
+            '',
+            '## Summary',
+            `**Score Delta:** ${deltaSign}${comparison.scoreDelta}`,
+            `**Grade Change:** ${comparison.gradeChange.from} → ${comparison.gradeChange.to}`,
+            `**New Issues:** ${comparison.newIssues.length}`,
+            `**Resolved Issues:** ${comparison.resolvedIssues.length}`,
+            `**Persistent Issues:** ${comparison.persistentIssues.length}`,
+            '',
+        ];
+        // Category changes
+        const categoryEntries = Object.entries(comparison.categoryChanges);
+        if (categoryEntries.length > 0) {
+            lines.push('## Category Changes');
+            lines.push('');
+            lines.push('| Category | Count Delta | Deduction Delta |');
+            lines.push('|----------|-------------|-----------------|');
+            for (const [category, changes] of categoryEntries) {
+                const countSign = changes.countDelta >= 0 ? '+' : '';
+                const deductionSign = changes.deductionDelta >= 0 ? '+' : '';
+                lines.push(`| ${category} | ${countSign}${changes.countDelta} | ${deductionSign}${changes.deductionDelta.toFixed(1)} |`);
+            }
+            lines.push('');
+        }
+        // New issues
+        if (comparison.newIssues.length > 0) {
+            lines.push('## New Issues');
+            for (const issue of comparison.newIssues) {
+                lines.push(`- **[${issue.severity}]** ${issue.message} (${issue.file})`);
+            }
+            lines.push('');
+        }
+        // Resolved issues
+        if (comparison.resolvedIssues.length > 0) {
+            lines.push('## Resolved Issues');
+            for (const issue of comparison.resolvedIssues) {
+                lines.push(`- **[${issue.severity}]** ${issue.message} (${issue.file})`);
+            }
+            lines.push('');
+        }
+        return createSuccessResult(lines.join('\n'));
+    }
+    static async handlePlan(args, service) {
+        if (!args.sourceRunId) {
+            return createErrorResult('sourceRunId is required for plan operation');
+        }
+        const run = await service.getRunDetails(args.sourceRunId);
+        if (!run) {
+            return createErrorResult(`Quality run not found: ${args.sourceRunId}`);
+        }
+        const plan = QualityService.generateImprovementPlan(run, args.targetGrade);
+        const result = await service.saveImprovementPlan(plan);
+        const totalInitiatives = plan.phases.reduce((sum, phase) => sum + phase.initiatives.length, 0);
+        const response = [
+            '✅ Quality Improvement Plan generated successfully!',
+            '',
+            `📋 Plan ID: ${result.planId}`,
+            `📁 File: ${result.filePath}`,
+            `📊 Current Score: ${plan.currentScore}/100 (Grade ${plan.currentGrade})`,
+            `🎯 Phases: ${plan.phases.length}`,
+            `📦 Initiatives: ${totalInitiatives}`,
+            `⏱️ Total Effort: ${plan.totalEffortHours} hours`,
+            '',
+            '## Executive Summary',
+            '',
+            plan.executiveSummary,
+            '',
+            'Use "quality plan-details planId=<id>" to see full plan details.',
+        ].join('\n');
+        return createSuccessResult(response);
+    }
+    static async handlePlanDetails(args, repositoryRoot) {
+        if (!args.planId) {
+            return createErrorResult('planId is required for plan-details operation');
+        }
+        try {
+            const plansDir = path.join(repositoryRoot, 'docs', 'quality', 'plans');
+            const filePath = path.join(plansDir, `${args.planId}.md`);
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Extract JSON from the Raw Data code block
+            const jsonMatch = content.match(/```json\n([\s\S]*?)\n```/);
+            if (!jsonMatch) {
+                return createErrorResult(`Could not parse plan data from: ${args.planId}`);
+            }
+            const planData = JSON.parse(jsonMatch[1]);
+            const lines = [
+                `📋 Quality Improvement Plan: ${planData.planId}`,
+                '',
+                '## Summary',
+                `**Date:** ${planData.date}`,
+                `**Source Run:** ${planData.sourceRunId}`,
+                `**Current Score:** ${planData.currentScore}/100 (Grade ${planData.currentGrade})`,
+                `**Total Effort:** ${planData.totalEffortHours} hours`,
+                '',
+                '## Executive Summary',
+                '',
+                planData.executiveSummary,
+                '',
+            ];
+            // Phase summaries
+            if (planData.phases && planData.phases.length > 0) {
+                lines.push('## Phases');
+                lines.push('');
+                for (const phase of planData.phases) {
+                    lines.push(`### Phase ${phase.phase}: ${phase.name}`);
+                    lines.push(`**Projected Score:** ${phase.projectedScore}/100 (Grade ${phase.projectedGrade})`);
+                    lines.push(`**Effort:** ${phase.totalEffortHours} hours`);
+                    lines.push(`**Initiatives:** ${phase.initiatives.length}`);
+                    lines.push('');
+                }
+            }
+            // ROI
+            if (planData.roiAnalysis) {
+                lines.push('## ROI Analysis');
+                lines.push(`**Estimated Cost:** ${planData.roiAnalysis.currency} ${planData.roiAnalysis.estimatedCostToFix}`);
+                lines.push('');
+            }
+            return createSuccessResult(lines.join('\n'));
+        }
+        catch {
+            return createErrorResult(`Improvement plan not found: ${args.planId}`);
+        }
+    }
+    static async handleDetectAnalyzers(repositoryRoot) {
+        const service = new AnalyzerDetectionService(repositoryRoot);
+        const analyzers = await service.detectAnalyzers();
+        if (analyzers.length === 0) {
+            return createSuccessResult('No static analyzers detected in this repository.\n\nSupported analyzers: ESLint, TypeScript, npm audit, RuboCop, ruff.');
+        }
+        const lines = [
+            `🔍 Detected ${analyzers.length} analyzer(s):`,
+            '',
+        ];
+        for (const analyzer of analyzers) {
+            lines.push(`- **${analyzer.name}** (${analyzer.analyzerId})`);
+            lines.push(`  Configs: ${analyzer.configPaths.join(', ')}`);
+            lines.push(`  Categories: ${analyzer.categories.join(', ')}`);
+        }
+        lines.push('');
+        lines.push(JSON.stringify(analyzers, null, 2));
+        return createSuccessResult(lines.join('\n'));
+    }
+    static async handleRunAnalyzers(repositoryRoot) {
+        const runId = generateRunId();
+        const runDir = path.join(repositoryRoot, 'docs', 'quality', 'runs', runIdToPath(runId));
+        const outputPath = path.join(runDir, 'analysis.json');
+        const outputDir = path.join(runDir, 'analysers');
+        const detectionService = new AnalyzerDetectionService(repositoryRoot);
+        const analyzers = await detectionService.detectAnalyzers();
+        const emptyResults = {
+            issues: [],
+            executions: [],
+            totalDurationMs: 0,
+            summary: { total: 0, succeeded: 0, failed: 0, timedOut: 0, skipped: 0 },
+        };
+        if (analyzers.length === 0) {
+            await fs.mkdir(runDir, { recursive: true });
+            await fs.writeFile(outputPath, JSON.stringify(emptyResults, null, 2), 'utf-8');
+            return createSuccessResult(`🔧 No analyzers detected. Empty results written to file.\n  Run ID: ${runId}\n  Output: ${outputPath}`);
+        }
+        const executorService = new AnalyzerExecutorService(repositoryRoot);
+        const results = await executorService.executeAnalyzers(analyzers, outputDir);
+        // Write merged/normalized result to the auto-generated run directory
+        await fs.mkdir(runDir, { recursive: true });
+        await fs.writeFile(outputPath, JSON.stringify(results, null, 2), 'utf-8');
+        const lines = [
+            `🔧 Executed ${results.summary.total} analyzer(s):`,
+            `  Succeeded: ${results.summary.succeeded}`,
+            `  Failed: ${results.summary.failed}`,
+            `  Total issues: ${results.issues.length}`,
+            `  Duration: ${results.totalDurationMs}ms`,
+            `  Run ID: ${runId}`,
+            `  Output: ${outputPath}`,
+            `  Raw files: ${outputDir}/`,
+        ];
+        return createSuccessResult(lines.join('\n'));
+    }
+    static async handleAssembleRun(args, repositoryRoot) {
+        if (!args.runId) {
+            return createErrorResult('runId is required for assemble-run operation (YYYY-MM-DD date prefix)');
+        }
+        const assemblyService = new AssemblyService(repositoryRoot);
+        const result = await assemblyService.assembleRun(args.runId, args.baseRunId);
+        const lines = [
+            '✅ Quality run assembled successfully!',
+            '',
+            `📊 Run ID: ${result.runId}`,
+            `📈 Score: ${result.score}/100 (Grade: ${result.grade})`,
+            `🔍 Issues: ${result.issueCount}`,
+            `📁 File: ${result.filePath}`,
+        ];
+        if (result.incremental) {
+            lines.push('');
+            lines.push('### Incremental Analysis');
+            lines.push(`  Base run: ${result.baseRunId}`);
+            lines.push(`  Files analyzed: ${result.filesAnalyzed}`);
+            lines.push(`  Files carried forward: ${result.filesCarriedForward}`);
+        }
+        lines.push('');
+        lines.push('### Source Breakdown');
+        lines.push(`  Analyzer: ${result.sourceBreakdown.analyzer}`);
+        lines.push(`  Specialist: ${result.sourceBreakdown.llm}`);
+        lines.push(`  Total: ${result.sourceBreakdown.total}`);
+        const categoryEntries = Object.entries(result.categoryBreakdown);
+        if (categoryEntries.length > 0) {
+            lines.push('');
+            lines.push('### Category Breakdown');
+            for (const [category, count] of categoryEntries) {
+                lines.push(`  ${category}: ${count}`);
+            }
+        }
+        return createSuccessResult(lines.join('\n'));
+    }
+    static handleMergeResults(args) {
+        const analyzerIssues = args.analyzerIssues ?? [];
+        const llmIssues = args.llmIssues ?? [];
+        const result = mergeResults(analyzerIssues, llmIssues);
+        const lines = [
+            `🔀 Merged results:`,
+            `  Analyzer issues: ${result.sourceBreakdown.analyzer}`,
+            `  LLM issues: ${result.sourceBreakdown.llm}`,
+            `  Total (deduplicated): ${result.sourceBreakdown.total}`,
+            `  Duplicates removed: ${result.duplicatesRemoved}`,
+            '',
+            JSON.stringify(result, null, 2),
+        ];
+        return createSuccessResult(lines.join('\n'));
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-ingredients/tiny-brain-local",
-  "version": "0.18.1",
+  "version": "0.19.1",
   "description": "MCP server for Tiny Brain AI assistant",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,7 @@
     "dxt:init": "cd dxt && dxt init"
   },
   "dependencies": {
-    "@magic-ingredients/tiny-brain-core": "^0.18.1",
+    "@magic-ingredients/tiny-brain-core": "^0.19.1",
     "@magic-ingredients/tiny-brain-dashboard": "file:../tiny-brain-dashboard",
     "@modelcontextprotocol/sdk": "^1.0.6",
     "chalk": "^5.3.0",