@atlassian/mcp-compressor 0.19.8 → 0.20.0

package/dist/local_tool_bridge.d.ts

@@ -4,4 +4,4 @@ export interface LocalToolBridge {
     token: string;
     close(): void;
 }
-export declare function startLocalToolBridge(tools: Record<string, ExecutableTool>): Promise<LocalToolBridge>;
+export declare function startLocalToolBridge(tools: Record<string, ExecutableTool<unknown>>): Promise<LocalToolBridge>;

package/dist/native.d.ts

@@ -6,6 +6,7 @@ export interface NativeToolSpec {
 export interface NativeCore {
     compressToolListingJson(level: string, toolsJson: string): string;
     formatToolSchemaResponseJson(toolJson: string): string;
+    maybeToonifyOutputJson(output: string): string;
     parseToolArgvJson(toolJson: string, argvJson: string): string;
     generateClientArtifactsJson(kind: string, configJson: string): string;
     generateClientArtifactFilesJson(kind: string, configJson: string): string;

package/dist/rust_core.d.ts

@@ -6,6 +6,7 @@ export interface ToolSpec {
 }
 export declare function compressToolListing(level: string, tools: ToolSpec[]): string;
 export declare function formatToolSchemaResponse(tool: ToolSpec): string;
+export declare function maybeToonifyOutput(output: string): string;
 export declare function parseToolArgv(tool: ToolSpec, argv: string[]): Record<string, unknown>;
 export type ClientArtifactKind = "cli" | "python" | "typescript";
 export interface ClientGeneratorConfig {

package/dist/rust_core.js

@@ -15,6 +15,9 @@ export function compressToolListing(level, tools) {
 export function formatToolSchemaResponse(tool) {
     return loadNativeCore().formatToolSchemaResponseJson(stringify(toNativeTool(tool)));
 }
+export function maybeToonifyOutput(output) {
+    return loadNativeCore().maybeToonifyOutputJson(output);
+}
 export function parseToolArgv(tool, argv) {
     return JSON.parse(loadNativeCore().parseToolArgvJson(stringify(toNativeTool(tool)), stringify(argv)));
 }

package/dist/tool_specs.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutableTool } from "./adapters.js";
 import type { ToolSpec } from "./rust_core.js";
-export declare function executableToolToSpec(name: string, tool: ExecutableTool): ToolSpec;
-export declare function executableToolsToSpecs(tools: Record<string, ExecutableTool>): ToolSpec[];
+export declare function executableToolToSpec(name: string, tool: ExecutableTool<unknown>): ToolSpec;
+export declare function executableToolsToSpecs(tools: Record<string, ExecutableTool<unknown>>): ToolSpec[];
 export declare function normalizeServerName(name: string | undefined): string;
 export declare function stringifyToolResult(value: unknown): string;
 export declare function normalizeStructuredArgValues(schema: Record<string, unknown>, input: Record<string, unknown>): Record<string, unknown>;

package/dist/transforms.d.ts

@@ -23,6 +23,6 @@ export interface GeneratedToolTransformResult extends GeneratedClientArtifactsRe
     tools: Record<string, ExecutableTool>;
     close(): void;
 }
-export declare function transformToolsForJustBash(tools: Record<string, ExecutableTool>, options: TransformToolsForJustBashOptions): JustBashTransformResult;
-export declare function transformToolsForCodeMode(tools: Record<string, ExecutableTool>, options: TransformToolsForCodeModeOptions): Promise<GeneratedToolTransformResult>;
-export declare function transformToolsForCliMode(tools: Record<string, ExecutableTool>, options?: TransformToolsForCliModeOptions): Promise<GeneratedToolTransformResult>;
+export declare function transformToolsForJustBash(tools: Record<string, ExecutableTool<unknown>>, options: TransformToolsForJustBashOptions): JustBashTransformResult;
+export declare function transformToolsForCodeMode(tools: Record<string, ExecutableTool<unknown>>, options: TransformToolsForCodeModeOptions): Promise<GeneratedToolTransformResult>;
+export declare function transformToolsForCliMode(tools: Record<string, ExecutableTool<unknown>>, options?: TransformToolsForCliModeOptions): Promise<GeneratedToolTransformResult>;

package/dist/transforms.js

@@ -1,18 +1,19 @@
 import { generateClientFromBridge, } from "./generated_clients.js";
 import { createJustBashCommandRegistrations, installJustBashRegistrations, } from "./just_bash_commands.js";
 import { startLocalToolBridge } from "./local_tool_bridge.js";
+import { maybeToonifyOutput } from "./rust_core.js";
 import { executableToolToSpec, executableToolsToSpecs, normalizeServerName, stringifyToolResult, } from "./tool_specs.js";
 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);
     return {
         registrations,
         tools: helpTools({
             serverName,
-            mode: "Just Bash",
-            summary: `Backend tools have been installed as Just Bash commands for ${serverName}.`,
-            lines: registrations.map((registration) => `- ${registration.commandName}`),
+            description: helpDescription,
+            output: helpDescription,
         }),
     };
 }
@@ -22,16 +23,16 @@ export async function transformToolsForCodeMode(tools, options) {
         kind: options.language,
         serverName,
         outputDir: options.outputDir ?? "./dist",
-        modeLabel: options.language === "python" ? "Python Code Mode" : "TypeScript Code Mode",
     });
 }
 export async function transformToolsForCliMode(tools, options = {}) {
     const serverName = normalizeServerName(options.serverName);
+    const output = options.outputDir === undefined ? defaultCliOutputDir() : { outputDir: options.outputDir };
     return generatedTransform(tools, {
         kind: "cli",
         serverName,
-        outputDir: options.outputDir ?? "./dist",
-        modeLabel: "CLI Mode",
+        outputDir: output.outputDir,
+        commandName: serverName,
     });
 }
 function justBashSource(serverName, name, tool) {
@@ -41,7 +42,7 @@ function justBashSource(serverName, name, tool) {
         backendToolName: name,
         helpToolName: `${serverName}_help`,
         tool: executableToolToSpec(name, tool),
-        invoke: async (input) => stringifyToolResult(await tool.execute(input)),
+        invoke: async (input) => maybeToonifyOutput(stringifyToolResult(await tool.execute(input))),
     };
 }
 async function generatedTransform(tools, options) {
@@ -54,13 +55,19 @@ async function generatedTransform(tools, options) {
         tools: executableToolsToSpecs(tools),
         outputDir: options.outputDir,
     });
+    const helpDescription = generatedHelpDescription({
+        kind: options.kind,
+        serverName: options.serverName,
+        outputDir: options.outputDir,
+        files: Object.keys(generated.files),
+        commandName: options.commandName,
+    });
     return {
         ...generated,
         tools: helpTools({
             serverName: options.serverName,
-            mode: options.modeLabel,
-            summary: `${options.modeLabel} generated client files for ${options.serverName}.`,
-            lines: Object.keys(generated.files).map((file) => `- ${options.outputDir}/${file}`),
+            description: helpDescription,
+            output: helpDescription,
         }),
         close: () => bridge.close(),
     };
@@ -70,9 +77,71 @@ function helpTools(options) {
     return {
         [name]: {
             name,
-            description: `Show help for ${options.mode} tools generated from ${options.serverName}.`,
+            description: options.description,
             inputSchema: { type: "object", properties: {} },
-            execute: async () => [options.summary, "", ...options.lines].join("\n"),
+            execute: async () => options.output,
         },
     };
 }
+function generatedHelpDescription(options) {
+    if (options.kind === "cli") {
+        const command = options.commandName ?? `${options.outputDir}/${options.serverName}`;
+        return cliHelpDescription(command, options.serverName);
+    }
+    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");
+}
+function cliHelpDescription(command, cliName) {
+    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`,
+        "",
+        "When relevant, outputs from this CLI will prefer using the TOON format for more efficient representation of data.",
+        "",
+        "USAGE:",
+        `  ${command} <subcommand> [options]`,
+        "",
+        "SUBCOMMANDS:",
+        `  Run '${command} --help' in the shell for available subcommands.`,
+        "",
+        `Run '${command} --help' in the shell for usage.`,
+        `Run '${command} <subcommand> --help' for per-command help.`,
+        `Run '${command} <subcommand> [options]' to invoke a tool.`,
+    ].join("\n");
+}
+function justBashHelpDescription(serverName, registrations) {
+    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`,
+        "",
+        "When relevant, outputs from these commands will prefer using the TOON format for more efficient representation of data.",
+        "",
+        "COMMANDS:",
+        ...registrations.map((registration) => `  ${registration.commandName}`),
+        "",
+        "Run these commands with the bash tool.",
+    ].join("\n");
+}
+function defaultCliOutputDir() {
+    const envDir = process.env.MCP_COMPRESSOR_CLI_OUTPUT_DIR;
+    if (envDir !== undefined && envDir.length > 0) {
+        return { outputDir: envDir };
+    }
+    const home = process.env.HOME;
+    if (home !== undefined && home.length > 0) {
+        return { outputDir: `${home}/.local/bin` };
+    }
+    return { outputDir: "./dist" };
+}

package/native/index.d.ts

@@ -18,6 +18,8 @@ export declare function generateClientArtifactsJson(kind: string, configJson: st
 
 export declare function listOauthCredentialsJson(): string
 
+export declare function maybeToonifyOutputJson(output: string): string
+
 export declare function normalizeServersJson(serversJson: string): string
 
 export declare function parseMcpConfigJson(configJson: string): string

package/native/index.js

@@ -583,6 +583,7 @@ module.exports.formatToolSchemaResponseJson = nativeBinding.formatToolSchemaResp
 module.exports.generateClientArtifactFilesJson = nativeBinding.generateClientArtifactFilesJson
 module.exports.generateClientArtifactsJson = nativeBinding.generateClientArtifactsJson
 module.exports.listOauthCredentialsJson = nativeBinding.listOauthCredentialsJson
+module.exports.maybeToonifyOutputJson = nativeBinding.maybeToonifyOutputJson
 module.exports.normalizeServersJson = nativeBinding.normalizeServersJson
 module.exports.parseMcpConfigJson = nativeBinding.parseMcpConfigJson
 module.exports.parseToolArgvJson = nativeBinding.parseToolArgvJson

package/package.json

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