@atlassian/mcp-compressor 0.21.1 → 0.21.3

package/dist/just_bash_commands.js

@@ -2,22 +2,42 @@ import { defineCommand } from "just-bash";
 import { parseToolArgv } from "./rust_core.js";
 import { normalizeStructuredArgValues } from "./tool_specs.js";
 export function createJustBashCommandRegistrations(sources) {
-    return sources.map((source) => ({
-        providerName: source.providerName,
-        commandName: source.commandName,
-        backendToolName: source.backendToolName,
-        helpToolName: source.helpToolName,
-        command: defineCommand(source.commandName, async (args) => {
-            try {
-                const parsedInput = parseToolArgv(source.tool, args);
-                const toolInput = normalizeStructuredArgValues(source.tool.inputSchema, parsedInput);
-                return output(await source.invoke(toolInput));
-            }
-            catch (error) {
-                return failure(error);
-            }
-        }),
-    }));
+    const grouped = new Map();
+    for (const source of sources) {
+        grouped.set(source.providerName, [...(grouped.get(source.providerName) ?? []), source]);
+    }
+    return [...grouped.entries()].map(([providerName, providerSources]) => {
+        const bySubcommand = new Map(providerSources.flatMap((source) => [
+            [source.commandName, source],
+            [source.backendToolName.replaceAll("_", "-"), source],
+            [source.backendToolName, source],
+        ]));
+        const first = providerSources[0];
+        return {
+            providerName,
+            commandName: providerName,
+            backendToolName: providerName,
+            helpToolName: first?.helpToolName ?? `${providerName}_help`,
+            command: defineCommand(providerName, async (args) => {
+                try {
+                    const [subcommand, ...toolArgs] = args;
+                    if (subcommand === undefined || subcommand === "--help" || subcommand === "-h") {
+                        return output(dispatcherHelp(providerName, providerSources));
+                    }
+                    const source = bySubcommand.get(subcommand);
+                    if (source === undefined) {
+                        throw new Error(`Unknown ${providerName} subcommand: ${subcommand}`);
+                    }
+                    const parsedInput = parseToolArgv(source.tool, toolArgs);
+                    const toolInput = normalizeStructuredArgValues(source.tool.inputSchema, parsedInput);
+                    return output(await source.invoke(toolInput));
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            }),
+        };
+    });
 }
 export function installJustBashRegistrations(bash, registrations) {
     const host = bash;
@@ -32,6 +52,22 @@ export function installJustBashRegistrations(bash, registrations) {
         ];
     }
 }
+function dispatcherHelp(providerName, sources) {
+    const maxNameLength = Math.max(...sources.map((source) => source.backendToolName.replaceAll("_", "-").length), 0);
+    return [
+        `${providerName} - the ${providerName} toolset`,
+        "",
+        "USAGE:",
+        `  ${providerName} <subcommand> [options]`,
+        "",
+        "SUBCOMMANDS:",
+        ...sources.map((source) => {
+            const description = (source.tool.description ?? "").replace(/\s+/g, " ").trim();
+            const subcommand = source.backendToolName.replaceAll("_", "-");
+            return `  ${subcommand.padEnd(maxNameLength + 2)}${description}`.trimEnd();
+        }),
+    ].join("\n");
+}
 function output(stdout) {
     return { stdout: `${stdout}\n`, stderr: "", exitCode: 0 };
 }

package/dist/tool_specs.js

@@ -17,7 +17,26 @@ export function normalizeServerName(name) {
     return normalized || "tools";
 }
 export function stringifyToolResult(value) {
-    return typeof value === "string" ? value : JSON.stringify(value);
+    if (typeof value === "string")
+        return value;
+    const mcpText = stringifyMcpTextContent(value);
+    if (mcpText !== undefined)
+        return mcpText;
+    return JSON.stringify(value);
+}
+function stringifyMcpTextContent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const content = value.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const textParts = content.flatMap((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return [];
+        const candidate = item;
+        return candidate.type === "text" && typeof candidate.text === "string" ? [candidate.text] : [];
+    });
+    return textParts.length > 0 ? textParts.join("\n") : undefined;
 }
 export function normalizeStructuredArgValues(schema, input) {
     const properties = schema.properties;

package/dist/transforms.js

@@ -7,7 +7,12 @@ export function transformToolsForJustBash(tools, options) {
     const serverName = normalizeServerName(options.serverName);
     const registrations = createJustBashCommandRegistrations(Object.entries(tools).map(([name, tool]) => justBashSource(serverName, name, tool)));
     installJustBashRegistrations(options.bash, registrations);
-    const helpDescription = justBashHelpDescription(serverName, registrations);
+    const helpDescription = shellToolHelpDescription({
+        command: serverName,
+        cliName: serverName,
+        tools: executableToolsToSpecs(tools),
+        commandNameForTool: cliSubcommandName,
+    });
     return {
         registrations,
         tools: helpTools({
@@ -89,43 +94,38 @@ function generatedHelpDescription(options) {
         const command = options.commandName ?? `${options.outputDir}/${options.serverName}`;
         return cliHelpDescription(command, options.serverName, options.tools);
     }
-    const language = options.kind === "python" ? "Python" : "TypeScript";
-    const moduleName = options.kind === "python" ? `${options.serverName}.py` : `${options.serverName}.ts`;
-    return [
-        `Functionality associated with the ${options.serverName} toolset is provided via generated ${language} code. Do not call this tool - import and use the generated code instead.`,
-        `${options.serverName} - the ${options.serverName} toolset`,
-        "",
-        `Generated files are available in ${options.outputDir}.`,
-        `Primary module: ${options.outputDir}/${moduleName}`,
-        "",
-        "When relevant, outputs from generated clients will prefer using the TOON format for more efficient representation of data.",
-        "",
-        "Available generated files:",
-        ...options.files.map((file) => `  - ${options.outputDir}/${file}`),
-    ].join("\n");
+    return codeHelpDescription(options);
 }
 function cliHelpDescription(command, cliName, tools) {
+    return shellToolHelpDescription({
+        command,
+        cliName,
+        tools,
+        commandNameForTool: cliSubcommandName,
+    });
+}
+function shellToolHelpDescription(options) {
     return [
-        `Functionality associated with the ${cliName} toolset is provided via the \`${command}\` CLI. Do not call this tool - use the CLI instead.`,
-        `${cliName} - the ${cliName} toolset`,
+        `Functionality associated with the ${options.cliName} toolset is provided via the \`${options.command}\` CLI. Do not call this tool - use the CLI instead.`,
+        `${options.cliName} - the ${options.cliName} toolset`,
         "",
         "When relevant, outputs from this CLI will prefer using the TOON format for more efficient representation of data.",
         "",
         "USAGE:",
-        `  ${command} <subcommand> [options]`,
+        `  ${options.command} <subcommand> [options]`,
         "",
         "SUBCOMMANDS:",
-        ...formatSubcommands(tools),
+        ...formatSubcommands(options.tools, options.commandNameForTool),
         "",
-        `Run '${command} --help' in the shell for usage.`,
-        `Run '${command} <subcommand> --help' for per-command help.`,
-        `Run '${command} <subcommand> [options]' to invoke a tool.`,
+        `Run '${options.command} --help' in the shell for usage.`,
+        `Run '${options.command} <subcommand> --help' for per-command help.`,
+        `Run '${options.command} <subcommand> [options]' to invoke a tool.`,
     ].join("\n");
 }
-function formatSubcommands(tools) {
-    const maxNameLength = Math.max(...tools.map((tool) => cliSubcommandName(tool.name).length), 0);
+function formatSubcommands(tools, commandNameForTool) {
+    const maxNameLength = Math.max(...tools.map((tool) => commandNameForTool(tool.name).length), 0);
     return tools.map((tool) => {
-        const subcommand = cliSubcommandName(tool.name);
+        const subcommand = commandNameForTool(tool.name);
         const description = compactDescription(tool.description ?? undefined);
         return `  ${subcommand.padEnd(maxNameLength + 2)}${description}`.trimEnd();
     });
@@ -136,19 +136,46 @@ function cliSubcommandName(toolName) {
 function compactDescription(description) {
     return (description ?? "").replace(/\s+/g, " ").trim();
 }
-function justBashHelpDescription(serverName, registrations) {
+function codeHelpDescription(options) {
+    const language = options.kind === "python" ? "Python" : "TypeScript";
+    const languageLower = options.kind === "python" ? "python" : "typescript";
+    const moduleName = options.kind === "python" ? `${options.serverName}.py` : `${options.serverName}.ts`;
+    const functions = formatCodeFunctions(options.kind, options.tools);
+    const details = options.kind === "python"
+        ? [
+            "For details on a specific function, run:",
+            "```python",
+            `from ${options.serverName} import <function>`,
+            "print(help(<function>))",
+            "```",
+        ]
+        : [
+            "For details on a specific function, inspect the generated TypeScript declarations or editor hover documentation.",
+            `Primary declarations: ${options.outputDir}/${options.serverName}.d.ts`,
+        ];
     return [
-        `Functionality associated with the ${serverName} toolset is provided via bash commands. Do not call this tool - use the bash commands instead.`,
-        `${serverName} - the ${serverName} toolset`,
+        `Functionality associated with the ${options.serverName} toolset is provided via a ${language} module. Do not call this tool - import and use the ${languageLower} functionality instead.`,
+        `${options.serverName} - the ${options.serverName} toolset`,
         "",
-        "When relevant, outputs from these commands will prefer using the TOON format for more efficient representation of data.",
+        `${language} source code is available in ${options.outputDir}/${moduleName}`,
         "",
-        "COMMANDS:",
-        ...registrations.map((registration) => `  ${registration.commandName}`),
+        "Available functions:",
+        ...functions,
         "",
-        "Run these commands with the bash tool.",
+        ...details,
     ].join("\n");
 }
+function formatCodeFunctions(kind, tools) {
+    const names = tools.map((tool) => (kind === "python" ? tool.name : snakeToCamel(tool.name)));
+    const maxNameLength = Math.max(...names.map((name) => name.length), 0);
+    return tools.map((tool, index) => {
+        const name = names[index] ?? tool.name;
+        return `  ${name.padEnd(maxNameLength + 2)}${compactDescription(tool.description ?? undefined)}`.trimEnd();
+    });
+}
+function snakeToCamel(name) {
+    return name.replace(/[_-]([a-zA-Z0-9])/g, (_match, char) => char.toUpperCase());
+}
 function defaultCliOutputDir() {
     const envDir = process.env.MCP_COMPRESSOR_CLI_OUTPUT_DIR;
     if (envDir !== undefined && envDir.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlassian/mcp-compressor",
-  "version": "0.21.1",
+  "version": "0.21.3",
   "description": "TypeScript MCP server wrapper for reducing tokens consumed by MCP tools.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/atlassian-labs/mcp-compressor",