@identikey/coding-mcp 2.0.1

package/build/tools/persona.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { callAIWithPersona } from "../common/personaClient.js";
+import { PersonaRegistry } from "../personas/types.js";
+/**
+ * Persona tool - Direct interaction with registered personas
+ * Allows calling any registered persona for advice, analysis, or conversation
+ */
+export const personaToolName = "persona";
+export const personaToolDescription = "Chat with a specific persona for specialized advice and analysis with personality";
+export const PersonaToolSchema = z.object({
+    persona_id: z
+        .string()
+        .describe("ID of the persona to interact with (e.g., 'charles')"),
+    query: z
+        .string()
+        .min(1, "Query is required")
+        .describe("Question or request for the persona"),
+    context: z
+        .string()
+        .optional()
+        .describe("Additional context or code for the persona to analyze"),
+    analysis_type: z
+        .enum(["comprehensive", "advice", "research", "review"])
+        .optional()
+        .default("advice")
+        .describe("Type of analysis needed"),
+    reasoning_effort: z
+        .enum(["low", "medium", "high"])
+        .optional()
+        .default("medium")
+        .describe("Reasoning effort level"),
+    tone_style: z
+        .enum(["concise", "detailed", "humorous", "straight"])
+        .optional()
+        .describe("Response tone (concise=direct, detailed=balanced, humorous=witty, straight=professional)"),
+    output_format: z
+        .enum(["tldr", "detailed", "dual"])
+        .optional()
+        .describe("Output format (tldr=brief summary, detailed=full analysis, dual=both)"),
+    audience_level: z
+        .enum(["beginner", "intermediate", "expert", "auto"])
+        .optional()
+        .describe("Target audience expertise level"),
+    include_diagrams: z
+        .boolean()
+        .optional()
+        .describe("Include visual diagrams where applicable"),
+    user_constraints: z
+        .string()
+        .optional()
+        .describe("User's constraints or context (e.g., 'tight deadline', 'legacy codebase')"),
+});
+export async function runPersonaTool(args) {
+    const { persona_id, query, context = "", analysis_type, reasoning_effort, tone_style, output_format, audience_level, include_diagrams, user_constraints, } = args;
+    // Verify persona exists
+    const persona = PersonaRegistry.get(persona_id);
+    if (!persona) {
+        const available = PersonaRegistry.list()
+            .map((p) => p.id)
+            .join(", ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Persona '${persona_id}' not found. Available personas: ${available || "none registered"}`,
+                },
+            ],
+        };
+    }
+    try {
+        // Build a simple system prompt for persona interaction
+        const systemPrompt = `You are having a conversation with the user, providing your expertise and guidance.
+    
+Your role is to be helpful while maintaining your distinct personality and expertise.
+Respond naturally and directly to their query.`;
+        const result = await callAIWithPersona({
+            systemPrompt,
+            task: query,
+            code: context,
+            analysisType: analysis_type,
+            reasoningEffort: reasoning_effort,
+            personaId: persona_id,
+            toneStyle: tone_style,
+            outputFormat: output_format,
+            audienceLevel: audience_level,
+            includeDiagrams: include_diagrams,
+            userConstraints: user_constraints,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error calling ${persona.name}: ${error.message || error}`,
+                },
+            ],
+        };
+    }
+}

package/build/tools/researcher.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/**
+ * Researcher tool
+ *   - Performs multi-source research using various search engines and APIs
+ *   - Manages sources with proper citation formatting
+ *   - Provides comprehensive research synthesis with source attribution
+ */
+export declare const researcherToolName = "researcher";
+export declare const researcherToolDescription = "Conducts comprehensive research using multiple sources, manages citations, and synthesizes information with proper source attribution.";
+export interface Source {
+    id: string;
+    title: string;
+    url: string;
+    snippet: string;
+    searchEngine: string;
+    timestamp: string;
+    relevanceScore?: number;
+    authors?: string[];
+    publishDate?: string;
+    domain?: string;
+}
+export interface ResearchResult {
+    query: string;
+    sources: Source[];
+    synthesis: string;
+    citations: Map<string, Source>;
+    searchEnginesUsed: string[];
+    timestamp: string;
+}
+export declare const ResearcherToolSchema: z.ZodObject<{
+    query: z.ZodString;
+    search_engines: z.ZodOptional<z.ZodArray<z.ZodEnum<["google", "xai", "arxiv", "wikipedia", "github", "stackexchange", "pubmed", "semantic_scholar"]>, "many">>;
+    max_results_per_engine: z.ZodOptional<z.ZodNumber>;
+    deep_search: z.ZodOptional<z.ZodBoolean>;
+    include_academic: z.ZodOptional<z.ZodBoolean>;
+    reasoning_effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    citation_style: z.ZodOptional<z.ZodEnum<["apa", "mla", "chicago", "ieee", "inline"]>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    reasoning_effort?: "low" | "medium" | "high" | undefined;
+    search_engines?: ("xai" | "google" | "arxiv" | "wikipedia" | "github" | "stackexchange" | "pubmed" | "semantic_scholar")[] | undefined;
+    max_results_per_engine?: number | undefined;
+    deep_search?: boolean | undefined;
+    include_academic?: boolean | undefined;
+    citation_style?: "apa" | "mla" | "chicago" | "ieee" | "inline" | undefined;
+}, {
+    query: string;
+    reasoning_effort?: "low" | "medium" | "high" | undefined;
+    search_engines?: ("xai" | "google" | "arxiv" | "wikipedia" | "github" | "stackexchange" | "pubmed" | "semantic_scholar")[] | undefined;
+    max_results_per_engine?: number | undefined;
+    deep_search?: boolean | undefined;
+    include_academic?: boolean | undefined;
+    citation_style?: "apa" | "mla" | "chicago" | "ieee" | "inline" | undefined;
+}>;
+export declare function runResearcherTool(args: z.infer<typeof ResearcherToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=researcher.d.ts.map

package/build/tools/researcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"researcher.d.ts","sourceRoot":"","sources":["../../src/tools/researcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB;;;;;GAKG;AAEH,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAC/C,eAAO,MAAM,yBAAyB,2IACoG,CAAC;AAG3I,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EA+C/B,CAAC;AAqPH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;GAiI3C"}

package/build/tools/researcher.js

@@ -0,0 +1,346 @@
+import { z } from "zod";
+import { callAIProvider } from "../common/apiClient.js";
+import { chooseProvider, } from "../common/providerConfig.js";
+import { RESEARCHER_SYSTEM_PROMPT } from "../prompts/researcherPrompts.js";
+/**
+ * Researcher tool
+ *   - Performs multi-source research using various search engines and APIs
+ *   - Manages sources with proper citation formatting
+ *   - Provides comprehensive research synthesis with source attribution
+ */
+export const researcherToolName = "researcher";
+export const researcherToolDescription = "Conducts comprehensive research using multiple sources, manages citations, and synthesizes information with proper source attribution.";
+export const ResearcherToolSchema = z.object({
+    query: z.string().min(1, "Research query is required."),
+    search_engines: z
+        .array(z.enum([
+        "google",
+        "xai",
+        "arxiv",
+        "wikipedia",
+        "github",
+        "stackexchange",
+        "pubmed",
+        "semantic_scholar",
+    ]))
+        .optional()
+        .describe("Search engines to use. Defaults to ['google', 'xai']. Available: google, xai, arxiv, wikipedia, github, stackexchange, pubmed, semantic_scholar"),
+    max_results_per_engine: z
+        .number()
+        .min(1)
+        .max(20)
+        .optional()
+        .describe("Maximum results per search engine (1-20). Defaults to 5."),
+    deep_search: z
+        .boolean()
+        .optional()
+        .describe("Whether to perform deep search by following links and extracting full content. Defaults to false."),
+    include_academic: z
+        .boolean()
+        .optional()
+        .describe("Whether to prioritize academic sources (arxiv, pubmed, semantic_scholar). Defaults to false."),
+    reasoning_effort: z
+        .enum(["low", "medium", "high"])
+        .optional()
+        .describe("How hard the AI should think when synthesizing results (low/medium/high). Defaults to high for research."),
+    citation_style: z
+        .enum(["apa", "mla", "chicago", "ieee", "inline"])
+        .optional()
+        .describe("Citation style to use. Defaults to 'inline' for easy reading."),
+});
+// Search API implementations
+async function searchGoogle(query, maxResults) {
+    // Google Custom Search API implementation
+    // Note: Requires GOOGLE_API_KEY and GOOGLE_CSE_ID environment variables
+    const apiKey = process.env.GOOGLE_API_KEY;
+    const cseId = process.env.GOOGLE_CSE_ID;
+    if (!apiKey || !cseId) {
+        console.warn("Google Search API credentials not configured");
+        return [];
+    }
+    try {
+        const url = `https://www.googleapis.com/customsearch/v1?key=${apiKey}&cx=${cseId}&q=${encodeURIComponent(query)}&num=${maxResults}`;
+        const response = await fetch(url);
+        const data = await response.json();
+        return (data.items || []).map((item, index) => ({
+            id: `google-${index}`,
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet || "",
+            searchEngine: "Google",
+            timestamp: new Date().toISOString(),
+            domain: new URL(item.link).hostname,
+        }));
+    }
+    catch (error) {
+        console.error("Google search error:", error);
+        return [];
+    }
+}
+async function searchXAI(query, maxResults) {
+    // X.AI/Perplexity API implementation
+    // This would integrate with Perplexity or X.AI's search capabilities
+    const apiKey = process.env.XAI_API_KEY || process.env.PERPLEXITY_API_KEY;
+    if (!apiKey) {
+        console.warn("X.AI/Perplexity API credentials not configured");
+        return [];
+    }
+    try {
+        // Perplexity API example
+        const response = await fetch("https://api.perplexity.ai/search", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query,
+                max_results: maxResults,
+                search_depth: "comprehensive",
+                include_sources: true,
+            }),
+        });
+        const data = await response.json();
+        return (data.sources || []).map((source, index) => ({
+            id: `xai-${index}`,
+            title: source.title,
+            url: source.url,
+            snippet: source.excerpt || "",
+            searchEngine: "X.AI/Perplexity",
+            timestamp: new Date().toISOString(),
+            domain: new URL(source.url).hostname,
+        }));
+    }
+    catch (error) {
+        console.error("X.AI search error:", error);
+        return [];
+    }
+}
+async function searchArxiv(query, maxResults) {
+    // ArXiv API implementation for academic papers
+    try {
+        const url = `http://export.arxiv.org/api/query?search_query=all:${encodeURIComponent(query)}&start=0&max_results=${maxResults}`;
+        const response = await fetch(url);
+        const text = await response.text();
+        // Simple XML parsing (in production, use a proper XML parser)
+        const entries = text.match(/<entry>[\s\S]*?<\/entry>/g) || [];
+        return entries.map((entry, index) => {
+            const title = (entry.match(/<title>([\s\S]*?)<\/title>/) || [])[1]?.trim() || "";
+            const summary = (entry.match(/<summary>([\s\S]*?)<\/summary>/) || [])[1]?.trim() || "";
+            const id = (entry.match(/<id>([\s\S]*?)<\/id>/) || [])[1]?.trim() || "";
+            const authors = (entry.match(/<author>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<\/author>/g) || [])
+                .map((a) => (a.match(/<name>([\s\S]*?)<\/name>/) || [])[1]?.trim())
+                .filter(Boolean);
+            return {
+                id: `arxiv-${index}`,
+                title,
+                url: id,
+                snippet: summary.substring(0, 200) + "...",
+                searchEngine: "ArXiv",
+                timestamp: new Date().toISOString(),
+                authors,
+                domain: "arxiv.org",
+            };
+        });
+    }
+    catch (error) {
+        console.error("ArXiv search error:", error);
+        return [];
+    }
+}
+async function searchWikipedia(query, maxResults) {
+    // Wikipedia API implementation
+    try {
+        const url = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&srlimit=${maxResults}`;
+        const response = await fetch(url);
+        const data = await response.json();
+        return (data.query?.search || []).map((item, index) => ({
+            id: `wiki-${index}`,
+            title: item.title,
+            url: `https://en.wikipedia.org/wiki/${encodeURIComponent(item.title.replace(/ /g, "_"))}`,
+            snippet: item.snippet.replace(/<[^>]*>/g, ""), // Remove HTML tags
+            searchEngine: "Wikipedia",
+            timestamp: new Date().toISOString(),
+            domain: "wikipedia.org",
+        }));
+    }
+    catch (error) {
+        console.error("Wikipedia search error:", error);
+        return [];
+    }
+}
+async function searchGitHub(query, maxResults) {
+    // GitHub API implementation for code/repository search
+    const token = process.env.GITHUB_TOKEN;
+    try {
+        const headers = { Accept: "application/vnd.github.v3+json" };
+        if (token)
+            headers["Authorization"] = `token ${token}`;
+        const url = `https://api.github.com/search/repositories?q=${encodeURIComponent(query)}&sort=stars&order=desc&per_page=${maxResults}`;
+        const response = await fetch(url, { headers });
+        const data = await response.json();
+        return (data.items || []).map((repo, index) => ({
+            id: `github-${index}`,
+            title: repo.full_name,
+            url: repo.html_url,
+            snippet: repo.description || "No description available",
+            searchEngine: "GitHub",
+            timestamp: new Date().toISOString(),
+            domain: "github.com",
+            relevanceScore: repo.stargazers_count,
+        }));
+    }
+    catch (error) {
+        console.error("GitHub search error:", error);
+        return [];
+    }
+}
+async function searchStackExchange(query, maxResults) {
+    // StackExchange API implementation
+    try {
+        const url = `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&q=${encodeURIComponent(query)}&site=stackoverflow&pagesize=${maxResults}`;
+        const response = await fetch(url);
+        const data = await response.json();
+        return (data.items || []).map((item, index) => ({
+            id: `stack-${index}`,
+            title: item.title,
+            url: item.link,
+            snippet: `Score: ${item.score}, Answers: ${item.answer_count}`,
+            searchEngine: "StackOverflow",
+            timestamp: new Date().toISOString(),
+            domain: "stackoverflow.com",
+            relevanceScore: item.score,
+        }));
+    }
+    catch (error) {
+        console.error("StackExchange search error:", error);
+        return [];
+    }
+}
+// Citation formatter
+function formatCitation(source, style) {
+    const date = new Date(source.timestamp).toLocaleDateString();
+    switch (style) {
+        case "apa":
+            return `${source.authors?.join(", ") || source.domain}. (${date}). ${source.title}. Retrieved from ${source.url}`;
+        case "mla":
+            return `${source.authors?.join(", ") || source.domain}. "${source.title}." Web. ${date}. <${source.url}>`;
+        case "chicago":
+            return `${source.authors?.join(", ") || source.domain}. "${source.title}." Accessed ${date}. ${source.url}.`;
+        case "ieee":
+            return `[${source.id}] ${source.authors?.join(", ") || source.domain}, "${source.title}," ${source.searchEngine}, ${date}. [Online]. Available: ${source.url}`;
+        case "inline":
+        default:
+            return `[${source.title}](${source.url}) - ${source.searchEngine}`;
+    }
+}
+// Main research function
+export async function runResearcherTool(args) {
+    const { query, search_engines = ["google", "xai"], max_results_per_engine = 5, deep_search = false, include_academic = false, reasoning_effort = "high", citation_style = "inline", } = args;
+    try {
+        // Expand search engines if academic sources requested
+        let engines = [...search_engines];
+        if (include_academic && !engines.includes("arxiv")) {
+            engines.push("arxiv");
+        }
+        if (include_academic && !engines.includes("semantic_scholar")) {
+            engines.push("semantic_scholar");
+        }
+        // Perform searches in parallel
+        const searchPromises = engines.map(async (engine) => {
+            switch (engine) {
+                case "google":
+                    return await searchGoogle(query, max_results_per_engine);
+                case "xai":
+                    return await searchXAI(query, max_results_per_engine);
+                case "arxiv":
+                    return await searchArxiv(query, max_results_per_engine);
+                case "wikipedia":
+                    return await searchWikipedia(query, max_results_per_engine);
+                case "github":
+                    return await searchGitHub(query, max_results_per_engine);
+                case "stackexchange":
+                    return await searchStackExchange(query, max_results_per_engine);
+                default:
+                    return [];
+            }
+        });
+        const searchResults = await Promise.all(searchPromises);
+        const allSources = searchResults.flat();
+        // Create citations map
+        const citations = new Map();
+        allSources.forEach((source) => {
+            citations.set(source.id, source);
+        });
+        // Prepare source content for AI synthesis
+        const sourcesContent = allSources
+            .map((source) => `[${source.id}] ${source.title}\n${source.searchEngine} - ${source.url}\n${source.snippet}\n`)
+            .join("\n---\n");
+        // Call AI provider for synthesis
+        const selectedProvider = chooseProvider({
+            analysisType: "research",
+            reasoningEffort: reasoning_effort,
+            textHint: query,
+        });
+        const synthesisPrompt = `Research Query: ${query}
+
+Sources Found:
+${sourcesContent}
+
+Please synthesize these sources into a comprehensive research summary. Include:
+1. Key findings and insights
+2. Conflicting information or debates
+3. Knowledge gaps or areas needing more research
+4. Proper source attribution using [source-id] references
+
+Citation Style: ${citation_style}`;
+        const synthesis = await callAIProvider({
+            systemPrompt: RESEARCHER_SYSTEM_PROMPT,
+            task: synthesisPrompt,
+            code: "", // Not needed for research
+            analysisType: "research",
+            reasoningEffort: reasoning_effort,
+            provider: selectedProvider,
+        });
+        // Format citations
+        const formattedCitations = allSources
+            .map((source) => formatCitation(source, citation_style))
+            .join("\n");
+        // Compile final result
+        const result = `# Research Results for: "${query}"
+
+## Summary
+${synthesis}
+
+## Sources Used (${allSources.length} total)
+${formattedCitations}
+
+## Search Engines Consulted
+${engines.join(", ")}
+
+## Metadata
+- Timestamp: ${new Date().toISOString()}
+- Deep Search: ${deep_search}
+- Academic Priority: ${include_academic}
+- Citation Style: ${citation_style}
+`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Research Error: ${error.message || error}`,
+                },
+            ],
+        };
+    }
+}

package/build/tools/screenshot.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/**
+ * Screenshot tool
+ *   - Takes in either "url" (a full URL) or "relativePath" to open on localhost:3000
+ *   - Returns a base64-encoded PNG screenshot
+ */
+export declare const screenshotToolName = "screenshot";
+export declare const screenshotToolDescription = "Take a screenshot of a URL or a local path (relative URL appended to http://localhost:3000).";
+export declare const ScreenshotToolSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    relativePath: z.ZodOptional<z.ZodString>;
+    fullPathToScreenshot: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    fullPathToScreenshot: string;
+    url?: string | undefined;
+    relativePath?: string | undefined;
+}, {
+    fullPathToScreenshot: string;
+    url?: string | undefined;
+    relativePath?: string | undefined;
+}>;
+export declare function runScreenshotTool(args: z.infer<typeof ScreenshotToolSchema>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=screenshot.d.ts.map

package/build/tools/screenshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenshot.d.ts","sourceRoot":"","sources":["../../src/tools/screenshot.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;GAIG;AAEH,eAAO,MAAM,kBAAkB,eAAe,CAAA;AAC9C,eAAO,MAAM,yBAAyB,iGAC0D,CAAA;AAEhG,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAA;AAEF,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC;;;;;GA+B3C"}

package/build/tools/screenshot.js

@@ -0,0 +1,46 @@
+import puppeteer from "puppeteer";
+import { z } from "zod";
+import path from "path";
+import fs from "fs";
+/**
+ * Screenshot tool
+ *   - Takes in either "url" (a full URL) or "relativePath" to open on localhost:3000
+ *   - Returns a base64-encoded PNG screenshot
+ */
+export const screenshotToolName = "screenshot";
+export const screenshotToolDescription = "Take a screenshot of a URL or a local path (relative URL appended to http://localhost:3000).";
+export const ScreenshotToolSchema = z.object({
+    url: z.string().optional(),
+    relativePath: z.string().optional(),
+    fullPathToScreenshot: z.string(),
+});
+export async function runScreenshotTool(args) {
+    // Determine final URL
+    let finalUrl = args.url;
+    if (!finalUrl) {
+        if (!args.relativePath) {
+            throw new Error("Must provide either 'url' or 'relativePath'");
+        }
+        finalUrl = `http://localhost:3000/${args.relativePath.replace(/^\//, "")}`;
+    }
+    const fullPathToScreenshot = path.resolve(args.fullPathToScreenshot);
+    // Launch Puppeteer
+    const browser = await puppeteer.launch();
+    const page = await browser.newPage();
+    await page.goto(finalUrl);
+    const screenshotBuffer = (await page.screenshot({
+        fullPage: true,
+    }));
+    await browser.close();
+    await fs.promises.writeFile(fullPathToScreenshot, screenshotBuffer);
+    // Return the base64 representation
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Screenshot saved to ${fullPathToScreenshot}. Before continuing, you MUST ask the user to drag and drop the screenshot into the chat window.
+        The path to the screenshot is ${fullPathToScreenshot}.`,
+            },
+        ],
+    };
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@identikey/coding-mcp",
+  "version": "2.0.1",
+  "description": "MCP Server with expert AI personas for code architecture, reviews, screenshots, and research",
+  "type": "module",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "start": "node build/index.js",
+    "test": "bun test",
+    "prepublishOnly": "npm run build"
+  },
+  "bin": {
+    "cursor-tools": "./build/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cursor",
+    "ai",
+    "code-review",
+    "architecture",
+    "personas",
+    "screenshot",
+    "developer-tools"
+  ],
+  "author": "Duke Jones",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/identikey/coding-mcp.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ai-sdk/xai": "^1.2.18",
+    "@modelcontextprotocol/sdk": "^1.4.1",
+    "ai": "^4.3.19",
+    "openai": "^4.82.0",
+    "puppeteer": "^24.1.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.15",
+    "@types/node": "^22.13.0",
+    "typescript": "^5.7.3"
+  }
+}