ladder-mcp 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to Ladder_mcp are documented here. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); this project uses
 [Semantic Versioning](https://semver.org/).
 
+## [1.0.1] - 2026-06-28
+
+Bug-fix release. Issues found by exercising all 20 tools live against a real
+Kimi CLI (the mock-only unit tests had missed them).
+
+### Fixed
+
+- **ACP responses lost spaces** (`kimi_chat`): streamed token chunks were each
+  trimmed and newline-joined, so `"Two plus two equals four."` came back as
+  `"Twoplustwoequalsfour."`. Text fragments are now concatenated as-is and only
+  the final string is trimmed. (CLI tools `kimi_analyze`/`kimi_resume` were never
+  affected.)
+- **`kimi_export_session` silently no-op'd** while reporting `ok: true`: when no
+  session id was given, `kimi export` defaults to the most recent session and asks
+  `Export previous session …? [Y/n]` — a prompt that `-y` does not suppress in Kimi
+  CLI 0.20.1, so with stdin closed it exited 0 without writing. The tool now
+  resolves the most recent session id itself and passes it explicitly (skipping the
+  prompt), always passes `-y`, and verifies the output file exists before reporting
+  success.
+
+### Changed
+
+- `kimi_acp_sessions` now accepts `limit` (default 20) and `work_dir` filters,
+  for parity with `kimi_list_sessions`; previously it dumped every ACP session
+  across all projects in one response.
+
 ## [1.0.0] - 2026-06-27
 
 First release. Windows-first MCP bridge for Kimi Code CLI v24, rebuilt in a

package/README.md

@@ -6,7 +6,8 @@ client like Claude Code can run codebase analysis, native sessions, API
 queries, ACP chat, background tasks, and CLI admin/diagnostics — all on Windows
 without hardcoded POSIX assumptions.
 
-> Status: **v1.0.0**. Supported platform is **Windows 11 only**.
+> Status: **v1.0.1** ([npm](https://www.npmjs.com/package/ladder-mcp)).
+> Supported platform is **Windows 11 only**.
 
 ## Requirements
 
@@ -15,40 +16,58 @@ without hardcoded POSIX assumptions.
 - Kimi Code CLI installed (`kimi.exe` on PATH or at `~/.kimi-code/bin/kimi.exe`),
   authenticated (`~/.kimi-code/`)
 
-## Install & build
+## Quick start (from npm)
 
-```bash
-npm install
-npm run build      # compiles src/ -> dist/ (tests excluded)
-```
+You don't need to clone or build — the package is published on npm and your MCP
+client launches it via `npx`.
 
-Quick checks:
+**Claude Code (one command):**
 
 ```bash
-npm test           # vitest (44 tests)
-npm run typecheck  # tsc --noEmit (incl. tests)
-npm run dev        # run the server from source via tsx
+claude mcp add kimi-code -- npx -y ladder-mcp
 ```
 
-## Run as an MCP server
-
-The server speaks MCP over stdio. Point your MCP client at the built entry:
+**Or add it manually to your MCP config:**
 
 ```jsonc
-// e.g. Claude Code MCP config
 {
   "mcpServers": {
     "kimi-code": {
-      "command": "node",
-      "args": ["C:\\path\\to\\Ladder_mcp\\dist\\index.js"]
+      "command": "npx",
+      "args": ["-y", "ladder-mcp"]
     }
   }
 }
 ```
 
+Then in Claude Code run `/mcp` (should show `kimi-code: connected`) and call
+`kimi_status` to confirm the environment is detected.
+
+> The server speaks MCP over **stdio**: it is launched and managed by the client,
+> not run by hand. Running `npx ladder-mcp` directly will appear to "hang" — that
+> is the server correctly waiting for a client. Exit with Ctrl+C.
+
+Prefer a global install? `npm install -g ladder-mcp`, then use `ladder-mcp` as the
+command instead of `npx -y ladder-mcp`.
+
 To let Kimi Code itself host this server, use the `kimi_generate_mcp_config`
 tool to produce/merge a `.kimi-code/mcp.json` entry.
 
+## Build from source (contributors)
+
+```bash
+npm install
+npm run build      # compiles src/ -> dist/ (tests excluded)
+```
+
+Quick checks:
+
+```bash
+npm test           # vitest (50 tests)
+npm run typecheck  # tsc --noEmit (incl. tests)
+npm run dev        # run the server from source via tsx
+```
+
 ## Tools
 
 **Core (v1)** — `kimi_analyze`, `kimi_query`, `kimi_verify`, `kimi_resume`,

package/dist/index.js

@@ -219,8 +219,11 @@ server.tool('kimi_chat', 'Send a prompt through Kimi ACP over stdio. Set backgro
     });
     return textResponse(JSON.stringify(result, null, 2), !result.ok);
 });
-server.tool('kimi_acp_sessions', 'List Kimi ACP sessions through `session/list`.', {}, async () => {
-    const result = await listAcpSessions();
+server.tool('kimi_acp_sessions', 'List Kimi ACP sessions through `session/list`.', {
+    limit: z.number().int().positive().optional(),
+    work_dir: z.string().optional(),
+}, async ({ limit, work_dir }) => {
+    const result = await listAcpSessions({ limit, workDir: work_dir });
     return textResponse(result.ok ? result.text : `Error: ${result.error}`, !result.ok);
 });
 server.tool('kimi_cancel', 'Cancel an active Ladder task by task_id or a Kimi ACP session by session_id.', {

package/dist/transports/acp.js

@@ -153,7 +153,11 @@ function extractTextDeep(value) {
     return [...direct, ...nested];
 }
 export function extractAcpText(value) {
-    return extractTextDeep(value).map((part) => part.trim()).filter(Boolean).join('\n');
+    // Concatenate text fragments as-is. Kimi streams the answer as many small
+    // agent_message_chunk tokens (e.g. "Two", " plus", " two"); trimming each
+    // fragment or joining on newlines would drop the spaces between tokens and
+    // run words together. Callers trim the final assembled string.
+    return extractTextDeep(value).join('');
 }
 // Keep the trailing portion of `text` within a UTF-8 *byte* budget. Slicing by
 // String length (UTF-16 code units) under-counts multibyte characters, so the
@@ -357,7 +361,9 @@ export async function runAcpPrompt(options) {
             sessionId = extractSessionId(await client.newSession(options.workDir));
         }
         const result = await client.prompt(sessionId, options.prompt, options.workDir);
-        let text = extractAcpText(result) || client.getUpdateText();
+        // extractAcpText no longer trims fragments (to preserve inter-token spaces),
+        // so trim the fully assembled string here. getUpdateText already trims.
+        let text = extractAcpText(result).trim() || client.getUpdateText();
         if (!text) {
             try {
                 text = JSON.stringify(result, null, 2);
@@ -385,11 +391,28 @@ export async function runAcpPrompt(options) {
         client.close();
     }
 }
-export async function listAcpSessions() {
+const DEFAULT_ACP_SESSION_LIMIT = 20;
+function normalizePath(value) {
+    return value.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+export async function listAcpSessions(options = {}) {
     const client = new AcpClient(60_000);
     try {
         await client.initialize();
         const result = await client.listSessions();
+        // Filter by working directory and cap the count for parity with kimi_list_sessions;
+        // session/list otherwise returns every ACP session across all projects in one blob.
+        const sessions = result?.sessions;
+        if (Array.isArray(sessions)) {
+            let filtered = sessions;
+            if (options.workDir) {
+                const target = normalizePath(options.workDir);
+                filtered = filtered.filter((s) => typeof s?.cwd === 'string' && normalizePath(s.cwd) === target);
+            }
+            const limit = options.limit ?? DEFAULT_ACP_SESSION_LIMIT;
+            const limited = limit > 0 ? filtered.slice(0, limit) : filtered;
+            return { ok: true, text: JSON.stringify({ sessions: limited, total: filtered.length }, null, 2) };
+        }
         return { ok: true, text: JSON.stringify(result, null, 2) };
     }
     catch (error) {

package/dist/transports/cli-admin.js

@@ -3,6 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { promisify } from 'node:util';
 import { buildKimiEnv, getKimiStatus, resolveKimiPaths } from '../environment.js';
+import { listSessions } from '../session-store.js';
 const execFileAsync = promisify(execFile);
 const ADMIN_TIMEOUT_MS = 30_000;
 // Quote a single argument for the human-readable preview command. This string is
@@ -76,8 +77,12 @@ export function buildExportArgs(options) {
     if (options.sessionId)
         args.push(options.sessionId);
     args.push('-o', options.outputPath);
-    if (options.overwriteExisting === true)
-        args.push('-y');
+    // Always auto-confirm. `kimi export` prompts "Export previous session …? [Y/n]"
+    // even for a brand-new path; since we close stdin, that prompt would get EOF and
+    // the export would silently no-op while still exiting 0. Overwrite safety is
+    // enforced by our own pre-check (assertSafeOutputPath + statSync + overwrite_existing),
+    // so unconditionally passing -y is safe.
+    args.push('-y');
     if (options.includeGlobalLog !== true)
         args.push('--no-include-global-log');
     return args;
@@ -179,6 +184,18 @@ export async function exportKimiSession(options) {
             error: error instanceof Error ? error.message : String(error),
         };
     }
+    // Resolve an explicit session id ourselves when the caller omitted one. `kimi export`
+    // otherwise defaults to "the most recent session" and asks "Export previous session …?
+    // [Y/n]" — a prompt that `-y` does NOT suppress in Kimi CLI 0.20.1, so with stdin closed
+    // it hangs/aborts and writes nothing. Passing an explicit id skips that prompt entirely.
+    let sessionId = options.sessionId;
+    if (!sessionId) {
+        const recent = listSessions({ limit: 1 })[0];
+        if (!recent) {
+            return { ok: false, stdout: '', stderr: '', error: 'No Kimi session found to export. Provide an explicit session_id.' };
+        }
+        sessionId = recent.id;
+    }
     const outputPath = path.resolve(options.outputPath);
     let existingStat;
     try {
@@ -207,7 +224,18 @@ export async function exportKimiSession(options) {
             };
         }
     }
-    return runKimiCommand(buildExportArgs({ ...options, outputPath }), 120_000);
+    const result = await runKimiCommand(buildExportArgs({ ...options, sessionId, outputPath }), 120_000);
+    // The CLI can exit 0 without producing the archive (e.g. a declined/aborted prompt).
+    // Verify the file actually exists so we never report success for a no-op export.
+    if (result.ok && !fs.existsSync(outputPath)) {
+        return {
+            ok: false,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            error: 'Kimi export exited without creating the output file. No archive was written.',
+        };
+    }
+    return result;
 }
 export function visualizeSession(options) {
     const binary = requireBinary();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ladder-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Windows-first MCP bridge for Kimi Code CLI v24",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,8 @@
     "build": "tsc -p tsconfig.build.json",
     "start": "node dist/index.js",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
   },
   "engines": {
     "node": ">=18.0.0"