@dropins/mcp 0.1.0

package/dist/common/project-reader.js

@@ -0,0 +1,173 @@
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join } from "path";
+import { validateBlockName, validatePathContainment } from "./sanitize.js";
+import { formatSuccessResponse } from "./response-handling.js";
+export function readPackageJson(projectDir) {
+    const filePath = join(projectDir, "package.json");
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function readConfigJson(projectDir) {
+    for (const name of ["config.json", "demo-config.json"]) {
+        const filePath = join(projectDir, name);
+        if (existsSync(filePath)) {
+            try {
+                return JSON.parse(readFileSync(filePath, "utf8"));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+export function listBlocks(projectDir) {
+    const blocksDir = join(projectDir, "blocks");
+    if (!existsSync(blocksDir))
+        return [];
+    try {
+        return readdirSync(blocksDir)
+            .filter((name) => {
+            const fullPath = join(blocksDir, name);
+            return statSync(fullPath).isDirectory();
+        })
+            .map((name) => {
+            const blockPath = join(blocksDir, name);
+            const jsFile = join(blockPath, `${name}.js`);
+            const cssFile = join(blockPath, `${name}.css`);
+            const hasJs = existsSync(jsFile);
+            const hasCss = existsSync(cssFile);
+            return {
+                name,
+                path: blockPath,
+                hasJs,
+                hasCss,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export function readBlockFile(projectDir, blockName) {
+    const error = validateBlockName(blockName);
+    if (error)
+        return null;
+    const jsFile = join(projectDir, "blocks", blockName, `${blockName}.js`);
+    if (!validatePathContainment(projectDir, jsFile))
+        return null;
+    if (!existsSync(jsFile))
+        return null;
+    try {
+        return readFileSync(jsFile, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function listInitializers(projectDir) {
+    const initDir = join(projectDir, "scripts", "initializers");
+    if (!existsSync(initDir))
+        return [];
+    try {
+        return readdirSync(initDir)
+            .filter((name) => name.endsWith(".js") && name !== "index.js")
+            .map((name) => ({
+            name: name.replace(".js", ""),
+            path: join(initDir, name),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function projectExists(projectDir) {
+    return existsSync(projectDir) && statSync(projectDir).isDirectory();
+}
+export function projectDirGuard(projectDir) {
+    if (!projectExists(projectDir)) {
+        return formatSuccessResponse("Project directory not found", {
+            error: "Directory does not exist",
+        });
+    }
+    return null;
+}
+export function extractDropinDependencies(pkg) {
+    const results = [];
+    for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
+        if (name.startsWith("@dropins/")) {
+            results.push({ name, version, isDev: false });
+        }
+    }
+    for (const [name, version] of Object.entries(pkg.devDependencies ?? {})) {
+        if (name.startsWith("@dropins/")) {
+            results.push({ name, version, isDev: true });
+        }
+    }
+    return results;
+}
+export function extractImportsFromBlock(jsContent) {
+    const dropinImports = [];
+    const containerImports = [];
+    const apiImports = [];
+    let eventImports = false;
+    const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(jsContent)) !== null) {
+        const importPath = match[1];
+        if (importPath.includes("@dropins/")) {
+            dropinImports.push(importPath);
+            if (importPath.includes("/containers/")) {
+                const containerName = importPath
+                    .split("/containers/")
+                    .pop()
+                    ?.replace(".js", "");
+                if (containerName)
+                    containerImports.push(containerName);
+            }
+            if (importPath.includes("/api")) {
+                apiImports.push(importPath);
+            }
+        }
+        if (importPath.includes("event-bus")) {
+            eventImports = true;
+        }
+    }
+    return { dropinImports, containerImports, apiImports, eventImports };
+}
+export const INITIALIZER_ALIASES = {
+    "storefront-product-discovery": "search",
+};
+export function initializerCandidates(dropinName) {
+    const shortName = dropinName.replace("storefront-", "");
+    const alias = INITIALIZER_ALIASES[dropinName];
+    const candidates = [`${dropinName}.js`, `${shortName}.js`];
+    if (alias)
+        candidates.push(`${alias}.js`);
+    return candidates;
+}
+export function readInitializerFile(projectDir, dropinName) {
+    const initDir = join(projectDir, "scripts", "initializers");
+    if (!existsSync(initDir))
+        return null;
+    for (const candidate of initializerCandidates(dropinName)) {
+        const filePath = join(initDir, candidate);
+        if (!validatePathContainment(projectDir, filePath))
+            continue;
+        if (existsSync(filePath)) {
+            try {
+                return readFileSync(filePath, "utf8");
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}

package/dist/common/registry-loader.d.ts

@@ -0,0 +1,101 @@
+import type { ApiFunctionDropinData, ApiFunctionRegistry, BlockPatternRegistry, ContainerDropinData, ContainerRegistry, DesignTokenCategory, DesignTokenRegistry, DocsIndex, DocsPage, DocsSection, EventCatalog, EventEntry, ExamplesDropinData, ExamplesIndex, ExtensionRegistry, GraphqlDropinData, GraphqlFragment, GraphqlOperation, GraphqlRegistry, I18nRegistry, SdkComponent, SdkFunction, SdkPackage, SdkRegistry, SlotContainerData, SlotDropinData, SlotRegistry } from "./types.js";
+export declare const getSlotRegistry: () => SlotRegistry;
+export declare const getEventCatalog: () => EventCatalog;
+export declare const getContainerRegistry: () => ContainerRegistry;
+export declare const getApiFunctionRegistry: () => ApiFunctionRegistry;
+export declare const getExtensionRegistry: () => ExtensionRegistry;
+export declare const getDesignTokenRegistry: () => DesignTokenRegistry;
+export declare const getBlockPatternRegistry: () => BlockPatternRegistry;
+export interface ModelEntry {
+    name: string;
+    kind: "interface" | "type";
+    definition: string;
+}
+export interface ModelsDropinData {
+    version: string;
+    models: ModelEntry[];
+}
+export interface ModelsRegistry {
+    version: string;
+    description: string;
+    dropins: Record<string, ModelsDropinData>;
+}
+export declare const getModelsRegistry: () => ModelsRegistry;
+export declare function getModelsByDropin(dropinName: string): ModelEntry[];
+export declare function findModel(modelName: string): Array<ModelEntry & {
+    dropin: string;
+}>;
+export declare function getSlotsByDropin(dropinName: string): SlotDropinData | null;
+export declare function getSlotsByContainer(dropinName: string, containerName: string): SlotContainerData | null;
+export declare function getEventsByDropin(dropinName: string, direction?: "emitted" | "consumed" | "all"): EventEntry[];
+export declare function getContainersByDropin(dropinName: string): ContainerDropinData | null;
+export declare function getApiFunctionsByDropin(dropinName: string): ApiFunctionDropinData | null;
+export declare function getDesignTokensByCategory(category: string): DesignTokenCategory | null;
+export declare function getAllDropinNames(): string[];
+export declare const getI18nRegistry: () => I18nRegistry;
+export declare const getGraphqlRegistry: () => GraphqlRegistry;
+export declare function getGraphqlByDropin(dropinName: string): GraphqlDropinData | null;
+interface ScoredField {
+    value: string;
+    wordWeight: number;
+    fullMatchWeight?: number;
+}
+export declare function tokenizeQuery(query: string, extraWords?: string[]): {
+    lowerQuery: string;
+    words: string[];
+};
+export declare function scoreItem(words: string[], lowerQuery: string, fields: ScoredField[]): number;
+export declare function topResults<T extends {
+    score: number;
+}>(results: T[], maxResults: number): T[];
+export interface GraphqlOperationResult {
+    operation: Pick<GraphqlOperation, "name" | "type" | "exportName" | "file" | "variables" | "fragmentDependencies">;
+    dropin: string;
+    score: number;
+}
+export interface GraphqlFragmentResult {
+    fragment: Pick<GraphqlFragment, "name" | "exportName" | "file" | "onType" | "exported" | "fragmentDependencies">;
+    dropin: string;
+    score: number;
+}
+export type GraphqlSearchResult = GraphqlOperationResult | GraphqlFragmentResult;
+export declare function searchGraphql(query: string, maxResults?: number, extraWords?: string[]): GraphqlSearchResult[];
+export interface SdkSearchResult {
+    item: (SdkFunction | SdkComponent) & {
+        packageName: string;
+        importPath?: string;
+    };
+    packageName: string;
+    type: "sdk-function" | "sdk-component";
+    score: number;
+}
+export declare const getSdkRegistry: () => SdkRegistry;
+export declare function getSdkPackage(packageName: string): SdkPackage | null;
+export declare function searchSdk(query: string, maxResults?: number, extraWords?: string[]): SdkSearchResult[];
+export interface DocsSearchResult {
+    page: Pick<DocsPage, "path" | "title" | "description">;
+    section: string;
+    sectionLabel: string;
+    score: number;
+}
+export declare const getDocsIndex: () => DocsIndex;
+export declare function getDocsSection(sectionKey: string): DocsSection | null;
+export interface ExamplesSearchResult {
+    example: {
+        id?: string;
+        name: string;
+        provider?: string;
+        description: string;
+        hooks?: string[];
+        fileNames?: string[];
+        sharedFiles?: string[];
+    };
+    dropin: string;
+    type: "extension" | "block" | "guide";
+    score: number;
+}
+export declare const getExamplesIndex: () => ExamplesIndex;
+export declare function getExamplesByDropin(dropinName: string): ExamplesDropinData | null;
+export declare function searchExamples(query: string, maxResults?: number, extraWords?: string[]): ExamplesSearchResult[];
+export declare function searchDocs(query: string, maxResults?: number, extraWords?: string[]): DocsSearchResult[];
+export {};

package/dist/common/registry-loader.js

@@ -0,0 +1,386 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const registryDir = join(__dirname, "..", "registry");
+function loadJson(filename) {
+    const filePath = join(registryDir, filename);
+    const content = readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+}
+function cachedLoader(filename) {
+    let cache = null;
+    return () => {
+        if (!cache)
+            cache = loadJson(filename);
+        return cache;
+    };
+}
+function cachedLoaderWithFallback(filename, fallback) {
+    let cache = null;
+    let loaded = false;
+    return () => {
+        if (!loaded) {
+            try {
+                cache = loadJson(filename);
+            }
+            catch {
+                cache = fallback;
+            }
+            loaded = true;
+        }
+        return cache;
+    };
+}
+const docsSectionCache = new Map();
+const examplesDropinCache = new Map();
+export const getSlotRegistry = cachedLoader("slots.json");
+export const getEventCatalog = cachedLoader("events.json");
+export const getContainerRegistry = cachedLoader("containers.json");
+export const getApiFunctionRegistry = cachedLoader("api-functions.json");
+export const getExtensionRegistry = cachedLoader("extensions.json");
+export const getDesignTokenRegistry = cachedLoader("design-tokens.json");
+export const getBlockPatternRegistry = cachedLoader("block-patterns.json");
+export const getModelsRegistry = cachedLoader("models.json");
+export function getModelsByDropin(dropinName) {
+    const registry = getModelsRegistry();
+    return registry.dropins[dropinName]?.models ?? [];
+}
+export function findModel(modelName) {
+    const registry = getModelsRegistry();
+    const results = [];
+    for (const [dropin, data] of Object.entries(registry.dropins)) {
+        const found = data.models.find((m) => m.name === modelName);
+        if (found)
+            results.push({ ...found, dropin });
+    }
+    return results;
+}
+export function getSlotsByDropin(dropinName) {
+    const registry = getSlotRegistry();
+    return registry.dropins[dropinName] ?? null;
+}
+export function getSlotsByContainer(dropinName, containerName) {
+    const dropin = getSlotsByDropin(dropinName);
+    if (!dropin)
+        return null;
+    return dropin.containers[containerName] ?? null;
+}
+export function getEventsByDropin(dropinName, direction) {
+    const catalog = getEventCatalog();
+    return catalog.events.filter((event) => {
+        const matchesEmit = event.emittedBy?.some((e) => e.dropin === dropinName);
+        const matchesConsume = event.consumedBy?.some((c) => c.dropin === dropinName);
+        if (direction === "emitted")
+            return matchesEmit;
+        if (direction === "consumed")
+            return matchesConsume;
+        return matchesEmit || matchesConsume;
+    });
+}
+export function getContainersByDropin(dropinName) {
+    const registry = getContainerRegistry();
+    return registry.dropins[dropinName] ?? null;
+}
+export function getApiFunctionsByDropin(dropinName) {
+    const registry = getApiFunctionRegistry();
+    return registry.dropins[dropinName] ?? null;
+}
+export function getDesignTokensByCategory(category) {
+    const registry = getDesignTokenRegistry();
+    return registry.categories[category] ?? null;
+}
+export function getAllDropinNames() {
+    const registry = getContainerRegistry();
+    return Object.keys(registry.dropins);
+}
+export const getI18nRegistry = cachedLoaderWithFallback("i18n.json", { version: "", description: "", dropins: {} });
+export const getGraphqlRegistry = cachedLoaderWithFallback("graphql.json", { version: "", description: "", dropins: {} });
+export function getGraphqlByDropin(dropinName) {
+    const registry = getGraphqlRegistry();
+    return registry.dropins[dropinName] ?? null;
+}
+export function tokenizeQuery(query, extraWords) {
+    const lowerQuery = query.toLowerCase();
+    const baseWords = lowerQuery.split(/\s+/).filter((w) => w.length > 2);
+    const words = extraWords?.length
+        ? [
+            ...new Set([
+                ...baseWords,
+                ...extraWords.map((w) => w.toLowerCase()).filter((w) => w.length > 2),
+            ]),
+        ]
+        : baseWords;
+    return { lowerQuery, words };
+}
+export function scoreItem(words, lowerQuery, fields) {
+    let score = 0;
+    for (const { value, wordWeight, fullMatchWeight } of fields) {
+        const lower = (value ?? "").toLowerCase();
+        for (const word of words) {
+            if (lower.includes(word))
+                score += wordWeight;
+        }
+        if (fullMatchWeight && lower.includes(lowerQuery))
+            score += fullMatchWeight;
+    }
+    return score;
+}
+export function topResults(results, maxResults) {
+    return [...results].sort((a, b) => b.score - a.score).slice(0, maxResults);
+}
+export function searchGraphql(query, maxResults = 10, extraWords) {
+    const registry = getGraphqlRegistry();
+    const { lowerQuery, words } = tokenizeQuery(query, extraWords);
+    const results = [];
+    for (const [dropinName, dropinData] of Object.entries(registry.dropins ?? {})) {
+        for (const op of dropinData.operations ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: op.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: op.exportName ?? "", wordWeight: 10 },
+                { value: op.type ?? "", wordWeight: 5 },
+                { value: op.source ?? "", wordWeight: 1 },
+            ]);
+            if (score > 0) {
+                results.push({
+                    operation: {
+                        name: op.name,
+                        type: op.type,
+                        exportName: op.exportName,
+                        file: op.file,
+                        variables: op.variables,
+                        fragmentDependencies: op.fragmentDependencies,
+                    },
+                    dropin: dropinName,
+                    score,
+                });
+            }
+        }
+        for (const frag of dropinData.fragments ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: frag.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: frag.exportName ?? "", wordWeight: 10 },
+                { value: frag.onType ?? "", wordWeight: 5 },
+                {
+                    value: frag.exported ? "exported extensible override" : "",
+                    wordWeight: 3,
+                },
+                { value: frag.source ?? "", wordWeight: 1 },
+            ]);
+            if (score > 0) {
+                results.push({
+                    fragment: {
+                        name: frag.name,
+                        exportName: frag.exportName,
+                        file: frag.file,
+                        onType: frag.onType,
+                        exported: frag.exported,
+                        fragmentDependencies: frag.fragmentDependencies,
+                    },
+                    dropin: dropinName,
+                    score,
+                });
+            }
+        }
+    }
+    return topResults(results, maxResults);
+}
+export const getSdkRegistry = cachedLoaderWithFallback("sdk.json", { description: "", packages: {} });
+export function getSdkPackage(packageName) {
+    const registry = getSdkRegistry();
+    return registry.packages[packageName] ?? null;
+}
+export function searchSdk(query, maxResults = 10, extraWords) {
+    const registry = getSdkRegistry();
+    const { lowerQuery, words } = tokenizeQuery(query, extraWords);
+    const results = [];
+    for (const [pkgKey, pkg] of Object.entries(registry.packages ?? {})) {
+        const pkgFields = [
+            { value: pkg.name ?? "", wordWeight: 3 },
+            { value: pkg.description ?? "", wordWeight: 1 },
+        ];
+        for (const fn of pkg.functions ?? pkg.utilities ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: fn.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: fn.description ?? "", wordWeight: 5 },
+                { value: fn.signature ?? "", wordWeight: 2 },
+                ...pkgFields,
+            ]);
+            if (score > 0) {
+                results.push({
+                    item: { ...fn, packageName: pkg.name },
+                    packageName: pkgKey,
+                    type: "sdk-function",
+                    score,
+                });
+            }
+        }
+        for (const comp of pkg.components ?? []) {
+            const slotNames = (comp.slots ?? []).join(" ");
+            const propNames = (comp.props ?? []).map((p) => p.name).join(" ");
+            const score = scoreItem(words, lowerQuery, [
+                { value: comp.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: comp.description ?? "", wordWeight: 5 },
+                { value: slotNames, wordWeight: 8 },
+                { value: propNames, wordWeight: 4 },
+                ...pkgFields,
+            ]);
+            if (score > 0) {
+                results.push({
+                    item: {
+                        ...comp,
+                        packageName: pkg.name,
+                        importPath: `${pkg.importPath}/components`,
+                    },
+                    packageName: pkgKey,
+                    type: "sdk-component",
+                    score,
+                });
+            }
+        }
+    }
+    return topResults(results, maxResults);
+}
+export const getDocsIndex = cachedLoaderWithFallback("docs/index.json", { totalPages: 0, totalSections: 0, priority: "", sections: [] });
+export function getDocsSection(sectionKey) {
+    if (docsSectionCache.has(sectionKey)) {
+        return docsSectionCache.get(sectionKey);
+    }
+    const index = getDocsIndex();
+    const sectionEntry = index.sections?.find((s) => s.section === sectionKey);
+    if (!sectionEntry)
+        return null;
+    try {
+        const data = loadJson(`docs/${sectionEntry.file}`);
+        docsSectionCache.set(sectionKey, data);
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export const getExamplesIndex = cachedLoaderWithFallback("examples/index.json", { version: "", totalExtensions: 0, totalBlocks: 0, dropins: [] });
+export function getExamplesByDropin(dropinName) {
+    if (examplesDropinCache.has(dropinName)) {
+        return examplesDropinCache.get(dropinName);
+    }
+    const index = getExamplesIndex();
+    const entry = index.dropins?.find((d) => d.dropin === dropinName);
+    if (!entry)
+        return null;
+    try {
+        const data = loadJson(`examples/${entry.file}`);
+        examplesDropinCache.set(dropinName, data);
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function searchExamples(query, maxResults = 10, extraWords) {
+    const index = getExamplesIndex();
+    const { lowerQuery, words } = tokenizeQuery(query, extraWords);
+    const results = [];
+    for (const entry of index.dropins ?? []) {
+        const data = getExamplesByDropin(entry.dropin);
+        if (!data)
+            continue;
+        for (const ext of data.extensions ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: ext.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: ext.id ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: ext.provider ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: ext.description ?? "", wordWeight: 5 },
+                {
+                    value: Object.values(ext.files ?? {}).join("\n"),
+                    wordWeight: 2,
+                },
+            ]);
+            if (score > 0) {
+                results.push({
+                    example: {
+                        id: ext.id,
+                        name: ext.name,
+                        provider: ext.provider,
+                        description: ext.description,
+                        hooks: ext.hooks,
+                        fileNames: Object.keys(ext.files ?? {}),
+                        sharedFiles: ext.sharedFiles,
+                    },
+                    dropin: entry.dropin,
+                    type: "extension",
+                    score,
+                });
+            }
+        }
+        for (const block of data.blocks ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: block.name ?? "", wordWeight: 15, fullMatchWeight: 25 },
+                { value: block.description ?? "", wordWeight: 5 },
+                {
+                    value: Object.values(block.files ?? {}).join("\n"),
+                    wordWeight: 2,
+                },
+            ]);
+            if (score > 0) {
+                results.push({
+                    example: {
+                        name: block.name,
+                        description: block.description,
+                        fileNames: Object.keys(block.files ?? {}),
+                    },
+                    dropin: entry.dropin,
+                    type: "block",
+                    score,
+                });
+            }
+        }
+        if (data.extensionGuide) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: data.extensionGuide, wordWeight: 1 },
+            ]);
+            if (score > 0) {
+                results.push({
+                    example: {
+                        name: "Extension Guide",
+                        description: `Extension system documentation for ${entry.dropin}`,
+                    },
+                    dropin: entry.dropin,
+                    type: "guide",
+                    score,
+                });
+            }
+        }
+    }
+    return topResults(results, maxResults);
+}
+export function searchDocs(query, maxResults = 10, extraWords) {
+    const index = getDocsIndex();
+    const { lowerQuery, words } = tokenizeQuery(query, extraWords);
+    const results = [];
+    for (const sectionEntry of index.sections ?? []) {
+        const section = getDocsSection(sectionEntry.section);
+        if (!section)
+            continue;
+        for (const page of section.pages ?? []) {
+            const score = scoreItem(words, lowerQuery, [
+                { value: page.title ?? "", wordWeight: 10, fullMatchWeight: 20 },
+                { value: page.description ?? "", wordWeight: 5, fullMatchWeight: 10 },
+                { value: page.content ?? "", wordWeight: 1 },
+            ]);
+            if (score > 0) {
+                results.push({
+                    page: {
+                        path: page.path,
+                        title: page.title,
+                        description: page.description,
+                    },
+                    section: sectionEntry.section,
+                    sectionLabel: sectionEntry.label,
+                    score,
+                });
+            }
+        }
+    }
+    return topResults(results, maxResults);
+}

package/dist/common/response-handling.d.ts

@@ -0,0 +1,12 @@
+export declare function formatSuccessResponse(message: string, data?: unknown): {
+    success: boolean;
+    message: string;
+    data: unknown;
+};
+declare function formatFailureResponse(message: string, data?: unknown): {
+    success: boolean;
+    message: string;
+    data: unknown;
+};
+export declare function formatExceptionResponse(error: unknown, operation: string): ReturnType<typeof formatFailureResponse>;
+export {};

package/dist/common/response-handling.js

@@ -0,0 +1,21 @@
+import { sanitizeErrorMessage } from "./sanitize.js";
+export function formatSuccessResponse(message, data) {
+    return {
+        success: true,
+        message,
+        data,
+    };
+}
+function formatFailureResponse(message, data) {
+    return {
+        success: false,
+        message,
+        data,
+    };
+}
+export function formatExceptionResponse(error, operation) {
+    const rawMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    process.stderr.write(`${operation} Error: ${rawMessage}\n`);
+    const safeMessage = sanitizeErrorMessage(rawMessage);
+    return formatFailureResponse(`Error ${operation}: ${safeMessage}`);
+}