@echoes-io/mcp-server 1.6.0 → 1.8.0

package/README.md

@@ -8,9 +8,27 @@ The server is distributed as an npm package and can be used without cloning the
 
 ### Using with MCP Clients
 
-**Important:** The server must be run from the `.github` directory of your Echoes project.
+The server can run in three modes depending on the working directory:
 
-Add to your MCP client configuration (e.g., `~/.config/q/mcp.json` for Amazon Q):
+1. **Single Timeline Mode**: Run from a `timeline-*` directory to work with that specific timeline
+2. **Multi-Timeline Mode**: Run from `.github` directory to access all timelines
+3. **Test Mode**: Run from `mcp-server` directory for development
+
+#### Single Timeline Configuration (Recommended for Kiro CLI)
+
+```json
+{
+  "mcpServers": {
+    "echoes": {
+      "command": "npx",
+      "args": ["-y", "@echoes-io/mcp-server"],
+      "cwd": "/path/to/timeline-pulse"
+    }
+  }
+}
+```
+
+#### Multi-Timeline Configuration (Legacy/CAO)
 
 ```json
 {
@@ -37,7 +55,7 @@ Then configure:
   "mcpServers": {
     "echoes": {
       "command": "echoes-mcp-server",
-      "cwd": "/path/to/echoes-io/.github",
+      "cwd": "/path/to/timeline-pulse",
       "env": {
         "ECHOES_RAG_PROVIDER": "e5-small"
       }
@@ -50,13 +68,49 @@ Then configure:
 - `ECHOES_RAG_PROVIDER`: Embedding provider (`e5-small`, `e5-large`, or `gemini`). Default: `e5-small`
 - `ECHOES_GEMINI_API_KEY`: Required if using `gemini` provider
 
-## Multi-Timeline Architecture
+## Execution Modes
+
+### Single Timeline Mode (Recommended)
+Run from a timeline directory to work with that specific timeline:
+```bash
+cd timeline-pulse
+npx @echoes-io/mcp-server
+# [DEBUG] Mode: single-timeline "pulse"
+```
+
+**Benefits:**
+- Simpler configuration for single-timeline workflows
+- Direct access to timeline databases
+- Perfect for Kiro CLI integration
+
+### Multi-Timeline Mode (Legacy)
+Run from `.github` directory to access all timelines:
+```bash
+cd .github
+npx @echoes-io/mcp-server
+# [DEBUG] Mode: multi-timeline (scanning /path/to/echoes-io)
+```
+
+**Benefits:**
+- Manage multiple timelines simultaneously
+- Backward compatible with CAO agents
+- Timeline repositories can be private
+
+### Test Mode
+Run from `mcp-server` directory for development:
+```bash
+cd mcp-server
+npm run dev
+# [DEBUG] Mode: test from mcp-server (in-memory)
+```
+
+## Timeline Architecture
 
-The server automatically discovers and manages multiple timelines:
+Each timeline has isolated databases in its own repository:
 
 ```
 echoes-io/
-  .github/              # Server runs from here
+  .github/              # Multi-timeline mode runs from here
   timeline-eros/        # Private timeline repo
     tracker.db          # Timeline-specific database
     rag.db              # Timeline-specific RAG index

package/lib/prompts/handlers.d.ts

@@ -0,0 +1,21 @@
+import type { Tracker } from '@echoes-io/tracker';
+export declare function listPrompts(): {
+    prompts: {
+        name: string;
+        description: string;
+        arguments: {
+            name: string;
+            description: string;
+            required: boolean;
+        }[];
+    }[];
+};
+export declare function getPrompt(name: string, args: Record<string, string>, timeline: string, tracker: Tracker): Promise<{
+    messages: {
+        role: "user";
+        content: {
+            type: "text";
+            text: string;
+        };
+    }[];
+}>;

package/lib/prompts/handlers.js

@@ -0,0 +1,107 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { substitutePlaceholders } from './substitution.js';
+import { validateGitHubRepo } from './validation.js';
+const PROMPTS = [
+    {
+        name: 'new-chapter',
+        description: 'Create a new chapter for a timeline arc',
+        arguments: [
+            { name: 'arc', description: 'Arc name (e.g., "work", "anima")', required: true },
+            { name: 'chapter', description: 'Chapter number (e.g., "1", "12")', required: true },
+        ],
+    },
+    {
+        name: 'revise-chapter',
+        description: 'Revise an existing chapter with specific improvements',
+        arguments: [
+            { name: 'arc', description: 'Arc name', required: true },
+            { name: 'chapter', description: 'Chapter number', required: true },
+        ],
+    },
+    {
+        name: 'expand-chapter',
+        description: 'Expand a chapter to reach target word count',
+        arguments: [
+            { name: 'arc', description: 'Arc name', required: true },
+            { name: 'chapter', description: 'Chapter number', required: true },
+            { name: 'target', description: 'Target word count (e.g., "4000")', required: true },
+        ],
+    },
+    {
+        name: 'new-character',
+        description: 'Create a new character sheet',
+        arguments: [{ name: 'name', description: 'Character name', required: true }],
+    },
+    {
+        name: 'new-episode',
+        description: 'Create a new episode outline',
+        arguments: [
+            { name: 'arc', description: 'Arc name', required: true },
+            { name: 'episode', description: 'Episode number', required: true },
+        ],
+    },
+    {
+        name: 'new-arc',
+        description: 'Create a new story arc',
+        arguments: [{ name: 'name', description: 'Arc name (lowercase, no spaces)', required: true }],
+    },
+];
+export function listPrompts() {
+    return { prompts: PROMPTS };
+}
+export async function getPrompt(name, args, timeline, tracker) {
+    try {
+        // Validate .github repo exists
+        const { exists: githubExists, path: githubPath } = validateGitHubRepo();
+        if (!githubExists) {
+            throw new Error('.github repository not found.\n' +
+                'Clone it as sibling: git clone https://github.com/echoes-io/.github ../.github');
+        }
+        // Read base template (required)
+        const basePath = join(githubPath, `${name}.md`);
+        if (!existsSync(basePath)) {
+            throw new Error(`Prompt template not found: ${name}.md\n` +
+                `Expected location: ../.github/.kiro/prompts/${name}.md`);
+        }
+        const basePrompt = await readFile(basePath, 'utf-8');
+        // Check for timeline override (optional)
+        const timelinePromptsPath = resolve(process.cwd(), '.kiro/prompts');
+        const overridePath = join(timelinePromptsPath, `${name}.md`);
+        let overridePrompt = '';
+        if (existsSync(overridePath)) {
+            overridePrompt = await readFile(overridePath, 'utf-8');
+        }
+        // Concatenate (base first, then override)
+        const combinedPrompt = overridePrompt
+            ? `${basePrompt}\n\n---\n\n${overridePrompt}`
+            : basePrompt;
+        // Substitute placeholders
+        const finalPrompt = await substitutePlaceholders(name, combinedPrompt, args, timeline, tracker);
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: finalPrompt,
+                    },
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `❌ Error loading prompt "${name}":\n\n${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                },
+            ],
+        };
+    }
+}

package/lib/prompts/index.d.ts

@@ -0,0 +1,2 @@
+export { getPrompt, listPrompts } from './handlers.js';
+export { validateGitHubRepo } from './validation.js';

package/lib/prompts/index.js

@@ -0,0 +1,2 @@
+export { getPrompt, listPrompts } from './handlers.js';
+export { validateGitHubRepo } from './validation.js';

package/lib/prompts/substitution.d.ts

@@ -0,0 +1,2 @@
+import type { Tracker } from '@echoes-io/tracker';
+export declare function substitutePlaceholders(promptName: string, template: string, args: Record<string, string>, timeline: string, tracker: Tracker): Promise<string>;

package/lib/prompts/substitution.js

@@ -0,0 +1,45 @@
+import { getAvailableArcs, validateArcExists, validateArcNotExists } from './validation.js';
+export async function substitutePlaceholders(promptName, template, args, timeline, tracker) {
+    const replacements = {
+        TIMELINE: timeline,
+        ...args,
+    };
+    // Prompt-specific validations
+    if (['new-chapter', 'revise-chapter', 'expand-chapter'].includes(promptName)) {
+        const { arc, chapter } = args;
+        if (!arc) {
+            throw new Error('Missing required argument: arc');
+        }
+        if (!chapter) {
+            throw new Error('Missing required argument: chapter');
+        }
+        // Validate arc exists
+        const arcExists = await validateArcExists(arc, tracker, timeline);
+        if (!arcExists) {
+            const available = await getAvailableArcs(tracker, timeline);
+            throw new Error(`Arc "${arc}" not found in tracker.\nAvailable arcs: ${available.join(', ') || 'none'}`);
+        }
+        // Validate chapter is a number
+        if (!/^\d+$/.test(chapter)) {
+            throw new Error(`Chapter must be a number, got: "${chapter}"`);
+        }
+    }
+    if (promptName === 'new-arc') {
+        const { name } = args;
+        if (!name) {
+            throw new Error('Missing required argument: name');
+        }
+        // Validate arc doesn't exist
+        const arcNotExists = await validateArcNotExists(name, tracker, timeline);
+        if (!arcNotExists) {
+            throw new Error(`Arc "${name}" already exists in tracker.`);
+        }
+    }
+    // Replace all placeholders
+    let result = template;
+    for (const [key, value] of Object.entries(replacements)) {
+        const placeholder = `{${key.toUpperCase()}}`;
+        result = result.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), value);
+    }
+    return result;
+}

package/lib/prompts/validation.d.ts

@@ -0,0 +1,8 @@
+import type { Tracker } from '@echoes-io/tracker';
+export declare function validateGitHubRepo(): {
+    exists: boolean;
+    path: string;
+};
+export declare function validateArcExists(arc: string, tracker: Tracker, timeline: string): Promise<boolean>;
+export declare function validateArcNotExists(arc: string, tracker: Tracker, timeline: string): Promise<boolean>;
+export declare function getAvailableArcs(tracker: Tracker, timeline: string): Promise<string[]>;

package/lib/prompts/validation.js

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+export function validateGitHubRepo() {
+    const githubPath = resolve(process.cwd(), '../.github/.kiro/prompts');
+    return {
+        exists: existsSync(githubPath),
+        path: githubPath,
+    };
+}
+export async function validateArcExists(arc, tracker, timeline) {
+    const arcs = await tracker.getArcs(timeline);
+    return arcs.some((a) => a.name === arc);
+}
+export async function validateArcNotExists(arc, tracker, timeline) {
+    return !(await validateArcExists(arc, tracker, timeline));
+}
+export async function getAvailableArcs(tracker, timeline) {
+    const arcs = await tracker.getArcs(timeline);
+    return arcs.map((a) => a.name);
+}

package/lib/server.d.ts

@@ -10,9 +10,18 @@ export declare function createServer(timelines: Map<string, TimelineContext>): S
     method: string;
     params?: {
         [x: string]: unknown;
+        task?: {
+            [x: string]: unknown;
+            ttl?: number | null | undefined;
+            pollInterval?: number | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
             progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
         } | undefined;
     } | undefined;
 }, {
@@ -21,12 +30,20 @@ export declare function createServer(timelines: Map<string, TimelineContext>): S
         [x: string]: unknown;
         _meta?: {
             [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
         } | undefined;
     } | undefined;
 }, {
     [x: string]: unknown;
     _meta?: {
         [x: string]: unknown;
+        "io.modelcontextprotocol/related-task"?: {
+            [x: string]: unknown;
+            taskId: string;
+        } | undefined;
     } | undefined;
 }>;
 interface TimelineContext {

package/lib/server.js

@@ -5,8 +5,9 @@ import { RAGSystem } from '@echoes-io/rag';
 import { Tracker } from '@echoes-io/tracker';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { toJsonSchemaCompat } from '@modelcontextprotocol/sdk/server/zod-json-schema-compat.js';
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { getPrompt, listPrompts, validateGitHubRepo } from './prompts/index.js';
 import { bookGenerate, bookGenerateSchema, chapterDelete, chapterDeleteSchema, chapterInfo, chapterInfoSchema, chapterInsert, chapterInsertSchema, chapterRefresh, chapterRefreshSchema, episodeInfo, episodeInfoSchema, episodeUpdate, episodeUpdateSchema, ragCharacters, ragCharactersSchema, ragContext, ragContextSchema, ragIndex, ragIndexSchema, ragSearch, ragSearchSchema, stats, statsSchema, timelineSync, timelineSyncSchema, wordsCount, wordsCountSchema, } from './tools/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
@@ -17,6 +18,7 @@ export function createServer(timelines) {
     }, {
         capabilities: {
             tools: {},
+            prompts: {},
         },
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -25,72 +27,72 @@ export function createServer(timelines) {
                 {
                     name: 'words-count',
                     description: 'Count words and text statistics in a markdown file',
-                    inputSchema: zodToJsonSchema(wordsCountSchema),
+                    inputSchema: toJsonSchemaCompat(wordsCountSchema),
                 },
                 {
                     name: 'chapter-info',
                     description: 'Extract chapter metadata, content preview, and statistics',
-                    inputSchema: zodToJsonSchema(chapterInfoSchema),
+                    inputSchema: toJsonSchemaCompat(chapterInfoSchema),
                 },
                 {
                     name: 'episode-info',
                     description: 'Get episode information and list of chapters',
-                    inputSchema: zodToJsonSchema(episodeInfoSchema),
+                    inputSchema: toJsonSchemaCompat(episodeInfoSchema),
                 },
                 {
                     name: 'episode-update',
                     description: 'Update episode metadata (description, title, slug)',
-                    inputSchema: zodToJsonSchema(episodeUpdateSchema),
+                    inputSchema: toJsonSchemaCompat(episodeUpdateSchema),
                 },
                 {
                     name: 'chapter-refresh',
                     description: 'Refresh chapter metadata and statistics from file',
-                    inputSchema: zodToJsonSchema(chapterRefreshSchema),
+                    inputSchema: toJsonSchemaCompat(chapterRefreshSchema),
                 },
                 {
                     name: 'chapter-delete',
                     description: 'Delete chapter from database and optionally from filesystem',
-                    inputSchema: zodToJsonSchema(chapterDeleteSchema),
+                    inputSchema: toJsonSchemaCompat(chapterDeleteSchema),
                 },
                 {
                     name: 'chapter-insert',
                     description: 'Insert new chapter and automatically renumber subsequent chapters',
-                    inputSchema: zodToJsonSchema(chapterInsertSchema),
+                    inputSchema: toJsonSchemaCompat(chapterInsertSchema),
                 },
                 {
                     name: 'timeline-sync',
                     description: 'Synchronize timeline content with database',
-                    inputSchema: zodToJsonSchema(timelineSyncSchema),
+                    inputSchema: toJsonSchemaCompat(timelineSyncSchema),
                 },
                 {
                     name: 'stats',
                     description: 'Get statistics for timeline, arc, episode, or POV',
-                    inputSchema: zodToJsonSchema(statsSchema),
+                    inputSchema: toJsonSchemaCompat(statsSchema),
                 },
                 {
                     name: 'rag-index',
                     description: 'Index chapters into RAG vector database for semantic search',
-                    inputSchema: zodToJsonSchema(ragIndexSchema),
+                    inputSchema: toJsonSchemaCompat(ragIndexSchema),
                 },
                 {
                     name: 'rag-search',
                     description: 'Semantic search across timeline content',
-                    inputSchema: zodToJsonSchema(ragSearchSchema),
+                    inputSchema: toJsonSchemaCompat(ragSearchSchema),
                 },
                 {
                     name: 'rag-context',
                     description: 'Retrieve relevant context for AI interactions',
-                    inputSchema: zodToJsonSchema(ragContextSchema),
+                    inputSchema: toJsonSchemaCompat(ragContextSchema),
                 },
                 {
                     name: 'rag-characters',
                     description: 'Get all characters that appear in chapters with a specific character',
-                    inputSchema: zodToJsonSchema(ragCharactersSchema),
+                    inputSchema: toJsonSchemaCompat(ragCharactersSchema),
                 },
                 {
                     name: 'book-generate',
                     description: 'Generate PDF book from timeline content using LaTeX',
-                    inputSchema: zodToJsonSchema(bookGenerateSchema),
+                    inputSchema: toJsonSchemaCompat(bookGenerateSchema),
                 },
             ],
         };
@@ -177,16 +179,39 @@ export function createServer(timelines) {
                 throw new Error(`Unknown tool: ${name}`);
         }
     });
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return listPrompts();
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        // Get timeline from first available timeline (single-timeline mode)
+        // or require timeline in args for multi-timeline mode
+        const timelineNames = Array.from(timelines.keys());
+        if (timelineNames.length === 0) {
+            throw new Error('No timelines available');
+        }
+        // For single-timeline mode, use the only timeline
+        // For multi-timeline mode, this would need timeline in args
+        const timeline = timelineNames[0];
+        const { tracker } = timelines.get(timeline);
+        return await getPrompt(name, args || {}, timeline, tracker);
+    });
     return server;
 }
 export async function runServer() {
-    // Validate we're running from .github directory
-    if (process.env.NODE_ENV !== 'test' && !process.cwd().endsWith('/.github')) {
-        throw new Error('Server must be run from .github directory');
-    }
+    const { readdirSync, existsSync } = await import('node:fs');
+    const { join, basename } = await import('node:path');
+    const cwd = process.cwd();
+    const cwdName = basename(cwd);
     const timelines = new Map();
+    const isTest = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+    const log = (...args) => {
+        if (!isTest)
+            log(...args);
+    };
+    log(`[DEBUG] Starting from: ${cwd}`);
     if (process.env.NODE_ENV === 'test') {
-        // Test mode: single in-memory database
+        // Test mode: in-memory databases
         const tracker = new Tracker(':memory:');
         await tracker.init();
         const rag = new RAGSystem({
@@ -194,29 +219,60 @@ export async function runServer() {
             dbPath: ':memory:',
         });
         timelines.set('test', { tracker, rag, contentPath: './test-content' });
-        console.error('Test mode: in-memory databases');
+        log('[DEBUG] Mode: test (in-memory)');
+    }
+    else if (cwdName.startsWith('timeline-')) {
+        // Single timeline mode: running from timeline directory
+        const timelineName = cwdName.replace('timeline-', '');
+        const contentPath = join(cwd, 'content');
+        if (!existsSync(contentPath)) {
+            throw new Error(`No content directory found in ${cwd}`);
+        }
+        const trackerPath = join(cwd, 'tracker.db');
+        const ragPath = join(cwd, 'rag.db');
+        const tracker = new Tracker(trackerPath);
+        await tracker.init();
+        const provider = (process.env.ECHOES_RAG_PROVIDER || 'e5-small');
+        const rag = new RAGSystem({
+            provider,
+            dbPath: ragPath,
+            geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
+        });
+        timelines.set(timelineName, { tracker, rag, contentPath });
+        log(`[DEBUG] Mode: single-timeline "${timelineName}"`);
+        log(`[DEBUG] Content: ${contentPath}`);
+        log(`[DEBUG] Tracker: ${trackerPath}`);
+        log(`[DEBUG] RAG: ${ragPath}`);
+    }
+    else if (cwdName === 'mcp-server') {
+        // Test mode from mcp-server directory: in-memory
+        const tracker = new Tracker(':memory:');
+        await tracker.init();
+        const rag = new RAGSystem({
+            provider: 'e5-small',
+            dbPath: ':memory:',
+        });
+        timelines.set('test', { tracker, rag, contentPath: './test-content' });
+        log('[DEBUG] Mode: test from mcp-server (in-memory)');
     }
     else {
-        // Production: discover timelines and create separate databases
-        const { readdirSync, existsSync, mkdirSync } = await import('node:fs');
-        const { join } = await import('node:path');
-        const parentDir = join(process.cwd(), '..');
+        // Multi-timeline mode: discover from parent directory (backward compat for .github)
+        const parentDir = join(cwd, '..');
         const entries = readdirSync(parentDir, { withFileTypes: true });
+        log(`[DEBUG] Mode: multi-timeline (scanning ${parentDir})`);
         for (const entry of entries) {
             if (entry.isDirectory() && entry.name.startsWith('timeline-')) {
                 const timelineName = entry.name.replace('timeline-', '');
                 const timelinePath = join(parentDir, entry.name);
                 const contentPath = join(timelinePath, 'content');
                 if (!existsSync(contentPath)) {
-                    console.error(`Skipping ${entry.name}: no content directory`);
+                    log(`[DEBUG] Skipping ${entry.name}: no content directory`);
                     continue;
                 }
-                // Initialize tracker
                 const trackerPath = join(timelinePath, 'tracker.db');
+                const ragPath = join(timelinePath, 'rag.db');
                 const tracker = new Tracker(trackerPath);
                 await tracker.init();
-                // Initialize RAG
-                const ragPath = join(timelinePath, 'rag.db');
                 const provider = (process.env.ECHOES_RAG_PROVIDER || 'e5-small');
                 const rag = new RAGSystem({
                     provider,
@@ -224,7 +280,7 @@ export async function runServer() {
                     geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
                 });
                 timelines.set(timelineName, { tracker, rag, contentPath });
-                console.error(`Timeline "${timelineName}" initialized: ${trackerPath}`);
+                log(`[DEBUG] Timeline "${timelineName}": ${trackerPath}`);
             }
         }
         if (timelines.size === 0) {
@@ -234,5 +290,16 @@ export async function runServer() {
     const server = createServer(timelines);
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error(`Echoes MCP Server running on stdio (${timelines.size} timelines)`);
+    log(`[DEBUG] Server ready with ${timelines.size} timeline(s)`);
+    // Validate .github repo for prompts
+    const { exists: githubExists, path: githubPath } = validateGitHubRepo();
+    if (!githubExists) {
+        log('⚠️  WARNING: .github repository not found');
+        log('   Expected location: ../.github/.kiro/prompts/');
+        log('   MCP prompts will not work until .github repo is cloned as sibling.');
+        log('   Clone: git clone https://github.com/echoes-io/.github ../.github');
+    }
+    else {
+        log('✓ .github repository found');
+    }
 }

package/lib/tools/book-generate.d.ts

@@ -3,18 +3,11 @@ export declare const bookGenerateSchema: z.ZodObject<{
     timeline: z.ZodString;
     outputPath: z.ZodString;
     episodes: z.ZodOptional<z.ZodString>;
-    format: z.ZodOptional<z.ZodEnum<["a4", "a5"]>>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    outputPath: string;
-    episodes?: string | undefined;
-    format?: "a4" | "a5" | undefined;
-}, {
-    timeline: string;
-    outputPath: string;
-    episodes?: string | undefined;
-    format?: "a4" | "a5" | undefined;
-}>;
+    format: z.ZodOptional<z.ZodEnum<{
+        a4: "a4";
+        a5: "a5";
+    }>>;
+}, z.core.$strip>;
 type BookGenerateArgs = z.infer<typeof bookGenerateSchema> & {
     contentPath: string;
 };

package/lib/tools/chapter-delete.d.ts

@@ -6,19 +6,7 @@ export declare const chapterDeleteSchema: z.ZodObject<{
     episode: z.ZodNumber;
     chapter: z.ZodNumber;
     file: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-    file?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-    file?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function chapterDelete(args: z.infer<typeof chapterDeleteSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/chapter-info.d.ts

@@ -5,17 +5,7 @@ export declare const chapterInfoSchema: z.ZodObject<{
     arc: z.ZodString;
     episode: z.ZodNumber;
     chapter: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    chapter: number;
-}>;
+}, z.core.$strip>;
 export declare function chapterInfo(args: z.infer<typeof chapterInfoSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/chapter-insert.d.ts

@@ -12,31 +12,7 @@ export declare const chapterInsertSchema: z.ZodObject<{
     outfit: z.ZodOptional<z.ZodString>;
     kink: z.ZodOptional<z.ZodString>;
     file: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    after: number;
-    pov: string;
-    title: string;
-    file?: string | undefined;
-    summary?: string | undefined;
-    location?: string | undefined;
-    outfit?: string | undefined;
-    kink?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    after: number;
-    pov: string;
-    title: string;
-    file?: string | undefined;
-    summary?: string | undefined;
-    location?: string | undefined;
-    outfit?: string | undefined;
-    kink?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function chapterInsert(args: z.infer<typeof chapterInsertSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/chapter-refresh.d.ts

@@ -3,13 +3,7 @@ import { z } from 'zod';
 export declare const chapterRefreshSchema: z.ZodObject<{
     timeline: z.ZodString;
     file: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    file: string;
-}, {
-    timeline: string;
-    file: string;
-}>;
+}, z.core.$strip>;
 export declare function chapterRefresh(args: z.infer<typeof chapterRefreshSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/episode-info.d.ts

@@ -4,15 +4,7 @@ export declare const episodeInfoSchema: z.ZodObject<{
     timeline: z.ZodString;
     arc: z.ZodString;
     episode: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-}>;
+}, z.core.$strip>;
 export declare function episodeInfo(args: z.infer<typeof episodeInfoSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/episode-update.d.ts

@@ -7,21 +7,7 @@ export declare const episodeUpdateSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
     slug: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    title?: string | undefined;
-    description?: string | undefined;
-    slug?: string | undefined;
-}, {
-    timeline: string;
-    arc: string;
-    episode: number;
-    title?: string | undefined;
-    description?: string | undefined;
-    slug?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function episodeUpdate(args: z.infer<typeof episodeUpdateSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-characters.d.ts

@@ -3,13 +3,7 @@ import { z } from 'zod';
 export declare const ragCharactersSchema: z.ZodObject<{
     timeline: z.ZodString;
     character: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    character: string;
-}, {
-    timeline: string;
-    character: string;
-}>;
+}, z.core.$strip>;
 export declare function ragCharacters(args: z.infer<typeof ragCharactersSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-context.d.ts

@@ -6,22 +6,8 @@ export declare const ragContextSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxChapters: z.ZodOptional<z.ZodNumber>;
-    characters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxChapters?: number | undefined;
-}, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxChapters?: number | undefined;
-}>;
+    characters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare function ragContext(args: z.infer<typeof ragContextSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/rag-index.d.ts

@@ -5,15 +5,7 @@ export declare const ragIndexSchema: z.ZodObject<{
     timeline: z.ZodString;
     arc: z.ZodOptional<z.ZodString>;
     episode: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-}, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-}>;
+}, z.core.$strip>;
 type RagIndexArgs = z.infer<typeof ragIndexSchema> & {
     contentPath: string;
 };

package/lib/tools/rag-search.d.ts

@@ -6,25 +6,9 @@ export declare const ragSearchSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
-    characters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    characters: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allCharacters: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxResults?: number | undefined;
-    allCharacters?: boolean | undefined;
-}, {
-    timeline: string;
-    query: string;
-    arc?: string | undefined;
-    pov?: string | undefined;
-    characters?: string[] | undefined;
-    maxResults?: number | undefined;
-    allCharacters?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export declare function ragSearch(args: z.infer<typeof ragSearchSchema>, rag: RAGSystem): Promise<{
     content: {
         type: "text";

package/lib/tools/stats.d.ts

@@ -5,17 +5,7 @@ export declare const statsSchema: z.ZodObject<{
     arc: z.ZodOptional<z.ZodString>;
     episode: z.ZodOptional<z.ZodNumber>;
     pov: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-    pov?: string | undefined;
-}, {
-    timeline: string;
-    arc?: string | undefined;
-    episode?: number | undefined;
-    pov?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare function stats(args: z.infer<typeof statsSchema>, tracker: Tracker): Promise<{
     content: {
         type: "text";

package/lib/tools/timeline-sync.d.ts

@@ -2,11 +2,7 @@ import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const timelineSyncSchema: z.ZodObject<{
     timeline: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    timeline: string;
-}, {
-    timeline: string;
-}>;
+}, z.core.$strip>;
 type TimelineSyncArgs = z.infer<typeof timelineSyncSchema> & {
     contentPath: string;
 };

package/lib/tools/words-count.d.ts

@@ -1,11 +1,7 @@
 import { z } from 'zod';
 export declare const wordsCountSchema: z.ZodObject<{
     file: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    file: string;
-}, {
-    file: string;
-}>;
+}, z.core.$strip>;
 export declare function wordsCount(args: z.infer<typeof wordsCountSchema>): Promise<{
     content: {
         type: "text";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echoes-io/mcp-server",
   "type": "module",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Model Context Protocol server for AI integration with Echoes storytelling platform",
   "scripts": {
     "dev": "tsx cli/index.ts",
@@ -63,30 +63,30 @@
     ]
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.3",
+    "@biomejs/biome": "^2.3.8",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@tsconfig/node22": "^22.0.2",
-    "@types/node": "^24.10.0",
-    "@vitest/coverage-v8": "^4.0.6",
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
     "concurrently": "^9.2.1",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.5",
+    "lint-staged": "^16.2.7",
     "lockfile-lint": "^4.14.1",
     "ls-engines": "^0.9.3",
     "publint": "^0.3.15",
-    "rimraf": "^6.1.0",
-    "semantic-release": "^25.0.1",
-    "tsx": "^4.19.2",
+    "rimraf": "^6.1.2",
+    "semantic-release": "^25.0.2",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.6"
+    "vitest": "^4.0.15"
   },
   "dependencies": {
-    "@echoes-io/books-generator": "^1.0.1",
-    "@echoes-io/models": "^1.0.3",
+    "@echoes-io/books-generator": "^1.1.0",
+    "@echoes-io/models": "^1.1.0",
     "@echoes-io/rag": "^1.2.0",
-    "@echoes-io/tracker": "^1.0.1",
-    "@echoes-io/utils": "^1.2.0",
-    "@modelcontextprotocol/sdk": "^1.0.2"
+    "@echoes-io/tracker": "^1.1.0",
+    "@echoes-io/utils": "^1.3.0",
+    "@modelcontextprotocol/sdk": "^1.24.2"
   }
 }