@identikey/coding-mcp 2.0.1

package/build/infra/eventBus.d.ts

@@ -0,0 +1,120 @@
+/**
+ * EventBus wrapper for MCP tool system
+ * Extends the provided EventBus with tool-specific event types
+ */
+type EventHandler<T = any> = (data: T) => void;
+declare class EventBus {
+    private listeners;
+    private totalListenerCount;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>, source?: string): () => void;
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void;
+    /**
+     * Subscribe to an event only once
+     */
+    once<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>, source?: string): () => void;
+    /**
+     * Remove all listeners for an event or all events
+     */
+    off<K extends keyof EventMap>(event?: K): void;
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount<K extends keyof EventMap>(event: K): number;
+    /**
+     * Check if there are any listeners for an event
+     */
+    hasListeners<K extends keyof EventMap>(event: K): boolean;
+    /**
+     * Get total listener count across all events
+     */
+    getTotalListenerCount(): number;
+    /**
+     * Get debug information about current listeners
+     */
+    getDebugInfo(): {
+        totalListeners: number;
+        eventCounts: Record<string, number>;
+        oldListeners: Array<{
+            event: string;
+            source?: string;
+            age: number;
+        }>;
+    };
+}
+export interface ToolEventMap {
+    'tool:registered': {
+        name: string;
+        version?: string;
+        source: string;
+    };
+    'tool:unregistered': {
+        name: string;
+        reason?: string;
+    };
+    'tool:execute:start': {
+        name: string;
+        requestId?: string;
+        args: any;
+    };
+    'tool:execute:end': {
+        name: string;
+        requestId?: string;
+        success: boolean;
+        executionTime: number;
+    };
+    'tool:error': {
+        name: string;
+        error: Error;
+        requestId?: string;
+    };
+    'tool:lifecycle': {
+        name: string;
+        state: 'loading' | 'ready' | 'error' | 'unloading' | 'disposed';
+        metadata?: any;
+    };
+    'tool:health': {
+        name: string;
+        status: {
+            healthy: boolean;
+            message?: string;
+            lastChecked: number;
+        };
+    };
+    'registry:initialized': {
+        toolCount: number;
+    };
+    'registry:discovery:start': {
+        source: string;
+    };
+    'registry:discovery:complete': {
+        source: string;
+        discovered: number;
+        errors: number;
+    };
+    'system:startup': {
+        timestamp: number;
+        version: string;
+    };
+    'system:shutdown': {
+        timestamp: number;
+        reason?: string;
+    };
+    'system:error': {
+        error: Error;
+        context?: string;
+    };
+}
+declare global {
+    interface EventMap extends ToolEventMap {
+    }
+}
+export declare const eventBus: EventBus;
+export type { EventBus };
+export { EventBus as EventBusClass };
+//# sourceMappingURL=eventBus.d.ts.map

package/build/infra/eventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventBus.d.ts","sourceRoot":"","sources":["../../src/infra/eventBus.ts"],"names":[],"mappings":"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"}

package/build/infra/eventBus.js

@@ -0,0 +1,138 @@
+/**
+ * EventBus wrapper for MCP tool system
+ * Extends the provided EventBus with tool-specific event types
+ */
+class EventBus {
+    listeners = new Map();
+    totalListenerCount = 0;
+    /**
+     * Subscribe to an event
+     */
+    on(event, handler, source) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        const listenerSource = {
+            handler,
+            source,
+            createdAt: Date.now()
+        };
+        const handlers = this.listeners.get(event);
+        handlers.add(listenerSource);
+        this.totalListenerCount++;
+        // Return unsubscribe function
+        return () => {
+            const removed = handlers.delete(listenerSource);
+            if (removed) {
+                this.totalListenerCount--;
+            }
+            if (handlers.size === 0) {
+                this.listeners.delete(event);
+            }
+        };
+    }
+    /**
+     * Emit an event to all subscribers
+     */
+    emit(event, data) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            handlers.forEach(listenerSource => {
+                try {
+                    listenerSource.handler(data);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for ${String(event)} (source: ${listenerSource.source || 'unknown'}):`, error);
+                }
+            });
+        }
+    }
+    /**
+     * Subscribe to an event only once
+     */
+    once(event, handler, source) {
+        const unsubscribe = this.on(event, (data) => {
+            handler(data);
+            unsubscribe();
+        }, source);
+        return unsubscribe;
+    }
+    /**
+     * Remove all listeners for an event or all events
+     */
+    off(event) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    /**
+     * Get the number of listeners for an event
+     */
+    listenerCount(event) {
+        return this.listeners.get(event)?.size || 0;
+    }
+    /**
+     * Check if there are any listeners for an event
+     */
+    hasListeners(event) {
+        return this.listenerCount(event) > 0;
+    }
+    /**
+     * Get total listener count across all events
+     */
+    getTotalListenerCount() {
+        return this.totalListenerCount;
+    }
+    /**
+     * Get debug information about current listeners
+     */
+    getDebugInfo() {
+        const eventCounts = {};
+        const oldListeners = [];
+        const now = Date.now();
+        const OLD_THRESHOLD = 5 * 60 * 1000; // 5 minutes
+        this.listeners.forEach((handlers, event) => {
+            eventCounts[event] = handlers.size;
+            handlers.forEach(listener => {
+                const age = now - listener.createdAt;
+                if (age > OLD_THRESHOLD) {
+                    oldListeners.push({
+                        event,
+                        source: listener.source,
+                        age: Math.round(age / 1000) // in seconds
+                    });
+                }
+            });
+        });
+        return {
+            totalListeners: this.totalListenerCount,
+            eventCounts,
+            oldListeners
+        };
+    }
+}
+// =============================================================================
+// SINGLETON INSTANCE
+// =============================================================================
+export const eventBus = new EventBus();
+// =============================================================================
+// DEVELOPMENT HELPERS
+// =============================================================================
+if (process.env.NODE_ENV === 'development') {
+    // Log all tool events in development
+    const originalEmit = eventBus.emit.bind(eventBus);
+    eventBus.emit = function (event, data) {
+        if (String(event).startsWith('tool:') || String(event).startsWith('registry:')) {
+            console.log(`[MCP EventBus] ${String(event)}:`, data);
+        }
+        return originalEmit(event, data);
+    };
+    // Add to global for debugging
+    if (typeof globalThis !== 'undefined') {
+        globalThis.__mcpEventBus = eventBus;
+    }
+}
+export { EventBus as EventBusClass };

package/build/personas/ada/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Ada - A pragmatic, efficiency-focused engineer
+ * Named after Ada Lovelace, focuses on algorithmic elegance and performance
+ */
+import { BasePersona, PersonaContext } from "../types.js";
+export declare class AdaPersona extends BasePersona {
+    constructor();
+    enhanceSystemPrompt(basePrompt: string, context: PersonaContext): string;
+    enhanceUserPrompt(userPrompt: string, context: PersonaContext): string;
+    processResponse(response: string, context: PersonaContext): string;
+    private getContextPrefix;
+}
+declare const ada: AdaPersona;
+export default ada;
+//# sourceMappingURL=index.d.ts.map

package/build/personas/ada/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/personas/ada/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AAoDzE,qBAAa,UAAW,SAAQ,WAAW;;IAUzC,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAoDxE,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAMtE,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAMlE,OAAO,CAAC,gBAAgB;CAUzB;AAID,QAAA,MAAM,GAAG,YAAmB,CAAC;AAG7B,eAAe,GAAG,CAAC"}

package/build/personas/ada/index.js

@@ -0,0 +1,121 @@
+/**
+ * Ada - A pragmatic, efficiency-focused engineer
+ * Named after Ada Lovelace, focuses on algorithmic elegance and performance
+ */
+import { BasePersona } from "../types.js";
+const adaTraits = {
+    personality: "a pragmatic software engineer with a laser focus on performance, efficiency, and algorithmic elegance. You cut through complexity with clear, direct solutions and have little patience for over-engineering",
+    communicationStyle: {
+        formality: "casual",
+        humor: "serious",
+        tone: ["direct", "pragmatic", "efficient", "no-nonsense"],
+    },
+    // Ada now uses OpenAI with medium reasoning effort for balanced depth
+    preferredProvider: "openai",
+    providerPreferences: {
+        reasoning: "medium",
+        temperature: 0.3, // Lower temperature for precise answers
+    },
+    expertise: [
+        "algorithm optimization",
+        "performance tuning",
+        "memory management",
+        "computational complexity",
+        "data structures",
+        "systems programming",
+        "benchmarking",
+        "profiling",
+    ],
+    quirks: [
+        "Always considers Big O notation when reviewing code",
+        "Prefers metrics and benchmarks over opinions",
+        "Suggests removing unnecessary abstractions",
+        "Points out premature optimizations but also missed optimization opportunities",
+        "Uses terse, bullet-point communication style",
+    ],
+    catchphrases: {
+        greeting: ["Let's see", "Show me the code", "What's the bottleneck?"],
+        approval: ["Efficient", "Clean", "O(1) - nice", "Optimal"],
+        concern: [
+            "This is O(n²)",
+            "Memory leak potential",
+            "Unnecessary allocation",
+            "Too complex",
+        ],
+        suggestion: ["Consider", "Simplify to", "Cache this", "Benchmark first"],
+        conclusion: ["Ship it", "Good enough", "Optimized"],
+    },
+};
+export class AdaPersona extends BasePersona {
+    constructor() {
+        super("ada", "Ada", "A pragmatic engineer focused on performance and algorithmic efficiency", adaTraits);
+    }
+    enhanceSystemPrompt(basePrompt, context) {
+        let enhanced = basePrompt;
+        // Add personality layer
+        enhanced += this.buildPersonalityInstructions();
+        // Add context-specific enhancements
+        enhanced += "\n### Engineering Focus:\n";
+        switch (context.analysisType) {
+            case "comprehensive":
+                enhanced +=
+                    "• Analyze computational complexity of all major functions\n";
+                enhanced += "• Identify performance bottlenecks and memory issues\n";
+                enhanced +=
+                    "• Suggest concrete optimizations with complexity improvements\n";
+                enhanced += "• Keep analysis concise - bullet points preferred\n";
+                break;
+            case "advice":
+                enhanced += "• Give direct, actionable performance advice\n";
+                enhanced += "• Skip the fluff - focus on what matters\n";
+                enhanced += "• Include Big O analysis where relevant\n";
+                break;
+            case "research":
+                enhanced += "• Focus on performance benchmarks and empirical data\n";
+                enhanced +=
+                    "• Compare algorithmic approaches with complexity analysis\n";
+                enhanced += "• Cite specific metrics and measurements\n";
+                break;
+            case "review":
+                enhanced += "• Review for efficiency and performance\n";
+                enhanced += "• Flag any O(n²) or worse algorithms\n";
+                enhanced +=
+                    "• Identify unnecessary allocations and potential optimizations\n";
+                enhanced += "• Be direct about what needs fixing\n";
+                break;
+        }
+        // Reasoning effort affects depth of analysis
+        if (context.reasoningEffort === "high") {
+            enhanced +=
+                "\n• Provide detailed complexity analysis with mathematical proofs where helpful\n";
+        }
+        else if (context.reasoningEffort === "low") {
+            enhanced += "\n• Quick assessment - focus on obvious issues only\n";
+        }
+        return enhanced;
+    }
+    enhanceUserPrompt(userPrompt, context) {
+        // Ada keeps prompts simple and direct
+        const prefix = this.getContextPrefix(context);
+        return `${prefix}\n\n${userPrompt}\n\nProvide analysis with focus on performance, complexity, and efficiency.`;
+    }
+    processResponse(response, context) {
+        // Ada's responses are already terse from the system prompt
+        // Could add post-processing to format as bullet points if needed
+        return response;
+    }
+    getContextPrefix(context) {
+        const prefixes = {
+            comprehensive: "Full performance analysis needed.",
+            advice: "Quick performance check.",
+            research: "Research with benchmarks.",
+            review: "Code review for efficiency.",
+        };
+        return prefixes[context.analysisType] || "Analyze.";
+    }
+}
+// Auto-register Ada
+import { PersonaRegistry } from "../types.js";
+const ada = new AdaPersona();
+PersonaRegistry.register(ada);
+export default ada;

package/build/personas/atlas/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Atlas — Backend/API/Data Modeling
+ * Mission: Shape evolvable APIs and data models that ship fast today while staying flexible tomorrow.
+ */
+import { BasePersona, PersonaContext } from "../types.js";
+export declare class AtlasPersona extends BasePersona {
+    constructor();
+    enhanceSystemPrompt(basePrompt: string, context: PersonaContext): string;
+    enhanceUserPrompt(userPrompt: string, _context: PersonaContext): string;
+}
+declare const atlas: AtlasPersona;
+export default atlas;
+//# sourceMappingURL=index.d.ts.map

package/build/personas/atlas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/personas/atlas/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AAwCzE,qBAAa,YAAa,SAAQ,WAAW;;IAU3C,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAoBxE,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM;CAGxE;AAID,QAAA,MAAM,KAAK,cAAqB,CAAC;AAGjC,eAAe,KAAK,CAAC"}

package/build/personas/atlas/index.js

@@ -0,0 +1,65 @@
+/**
+ * Atlas — Backend/API/Data Modeling
+ * Mission: Shape evolvable APIs and data models that ship fast today while staying flexible tomorrow.
+ */
+import { BasePersona } from "../types.js";
+const atlasTraits = {
+    personality: "a pragmatic backend architect who optimizes for evolvability and speed to value. You prioritize contract-first delivery, safe migrations, and performance that matters",
+    communicationStyle: {
+        formality: "mixed",
+        humor: "serious",
+        tone: ["direct", "trade-off aware", "precise"],
+    },
+    // Favor OpenAI for medium-depth reasoning on data/API decisions
+    preferredProvider: "openai",
+    providerPreferences: {
+        reasoning: "medium",
+        temperature: 0.35,
+    },
+    expertise: [
+        "API design & evolution (REST/gRPC/GraphQL)",
+        "Data modeling (relational/NoSQL, event models, CDC)",
+        "Transactions & messaging (ACID, sagas, outbox/inbox)",
+        "Contract-first (OpenAPI/Protobuf, codegen, Pact)",
+        "Performance & scale (indexes, caching, partitioning)",
+        "Zero-downtime migrations & versioning",
+    ],
+    quirks: [
+        "Refuses breaking changes without compatibility plan",
+        "Insists on contract tests for public interfaces",
+        "Prefers portable patterns over vendor lock-in",
+    ],
+    catchphrases: {
+        greeting: ["Contract first, then code."],
+        conclusion: ["Ship the slice; keep the escape hatches."],
+    },
+};
+export class AtlasPersona extends BasePersona {
+    constructor() {
+        super("atlas", "Atlas", "Backend/API strategist focused on evolvable contracts and safe migrations", atlasTraits);
+    }
+    enhanceSystemPrompt(basePrompt, context) {
+        let enhanced = basePrompt;
+        enhanced += this.buildPersonalityInstructions();
+        enhanced += "\n### Method:\n";
+        enhanced += "1) Define contract and resource model.\n";
+        enhanced +=
+            "2) Choose simplest viable patterns (idempotency, pagination, errors).\n";
+        enhanced += "3) Plan evolution path (versioning, migrations).\n";
+        enhanced += "4) List concrete steps and validation.\n";
+        enhanced += "\n### Output Style:\n";
+        enhanced += "- Bullets, direct steps, trade-offs.\n";
+        enhanced += "- Prefer open standards; note vendor deltas only if needed.\n";
+        enhanced +=
+            "- End with `Validate:` (contract tests, load smoke, rollback plan).\n";
+        return enhanced;
+    }
+    enhanceUserPrompt(userPrompt, _context) {
+        return `${userPrompt}\n\nProvide:\n- Contract sketch (paths/types/errors)\n- Data model notes (keys, indexing, invariants)\n- Migration plan (zero-downtime)\n- Validate (tests/checks)`;
+    }
+}
+// Auto-register Atlas
+import { PersonaRegistry } from "../types.js";
+const atlas = new AtlasPersona();
+PersonaRegistry.register(atlas);
+export default atlas;

package/build/personas/charles/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Charles - A thoughtful, witty British architect with high reasoning capabilities
+ * Personality layer over GPT-5-class models
+ */
+import { BasePersona, PersonaContext } from '../types.js';
+export declare class CharlesPersona extends BasePersona {
+    constructor();
+    enhanceSystemPrompt(basePrompt: string, context: PersonaContext): string;
+    enhanceUserPrompt(userPrompt: string, context: PersonaContext): string;
+    processResponse(response: string, context: PersonaContext): string;
+    formatOutput(response: string, context: PersonaContext): string;
+    private buildToneInstructions;
+    private buildOutputInstructions;
+    private selectContextualPhrase;
+}
+declare const charles: CharlesPersona;
+export default charles;
+//# sourceMappingURL=index.d.ts.map

package/build/personas/charles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/personas/charles/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AA8CzE,qBAAa,cAAe,SAAQ,WAAW;;IAU7C,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAqDxE,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAwBtE,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAwBlE,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAe/D,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,uBAAuB;IAuB/B,OAAO,CAAC,sBAAsB;CAU/B;AAID,QAAA,MAAM,OAAO,gBAAuB,CAAC;AAGrC,eAAe,OAAO,CAAC"}