@echoes-io/mcp-server 1.0.0 → 1.2.0

package/README.md

@@ -15,7 +15,10 @@ Add to your MCP client configuration (e.g., `~/.config/q/mcp.json` for Amazon Q)
   "mcpServers": {
     "echoes": {
       "command": "npx",
-      "args": ["-y", "@echoes-io/mcp-server"]
+      "args": ["-y", "@echoes-io/mcp-server"],
+      "env": {
+        "ECHOES_TIMELINE": "your-timeline-name"
+      }
     }
   }
 }
@@ -33,21 +36,77 @@ Then configure:
 {
   "mcpServers": {
     "echoes": {
-      "command": "echoes-mcp-server"
+      "command": "echoes-mcp-server",
+      "env": {
+        "ECHOES_TIMELINE": "your-timeline-name",
+        "ECHOES_RAG_PROVIDER": "e5-small",
+        "ECHOES_CHROMA_URL": "./rag_data"
+      }
     }
   }
 }
 ```
 
-## Usage
-
-Once configured, the server provides tools for:
-- Content management (chapters, episodes, arcs)
-- Word counting and text statistics
-- Database operations via @echoes-io/tracker
-- Timeline synchronization
-
-Available tools will be listed by your MCP client.
+**Important:** The `ECHOES_TIMELINE` environment variable must be set to specify which timeline to work with. All tools operate on this timeline.
+
+**Optional RAG Configuration:**
+- `ECHOES_RAG_PROVIDER`: Embedding provider (`e5-small`, `e5-large`, or `gemini`). Default: `e5-small`
+- `ECHOES_GEMINI_API_KEY`: Required if using `gemini` provider
+- `ECHOES_CHROMA_URL`: ChromaDB storage path. Default: `./rag_data`
+
+## Available Tools
+
+All tools operate on the timeline specified by the `ECHOES_TIMELINE` environment variable.
+
+### Content Operations
+- **`words-count`** - Count words and text statistics in markdown files
+  - Input: `file` (path to markdown file)
+  
+- **`chapter-info`** - Extract chapter metadata from database
+  - Input: `arc`, `episode`, `chapter`
+  
+- **`chapter-refresh`** - Refresh chapter metadata and word counts from file
+  - Input: `file` (path to chapter file)
+  
+- **`chapter-insert`** - Insert new chapter with automatic renumbering
+  - Input: `arc`, `episode`, `after`, `pov`, `title`, optional: `excerpt`, `location`, `outfit`, `kink`, `file`
+  
+- **`chapter-delete`** - Delete chapter from database and optionally from filesystem
+  - Input: `arc`, `episode`, `chapter`, optional: `file` (to delete from filesystem)
+
+### Episode Operations
+- **`episode-info`** - Get episode information and list of chapters
+  - Input: `arc`, `episode`
+  
+- **`episode-update`** - Update episode metadata (description, title, slug)
+  - Input: `arc`, `episode`, optional: `description`, `title`, `slug`
+
+### Timeline Operations
+- **`timeline-sync`** - Synchronize filesystem content with database
+  - Input: `contentPath` (path to content directory)
+
+### Statistics
+- **`stats`** - Get aggregate statistics with optional filters
+  - Input: optional: `arc`, `episode`, `pov`
+  - Output: Total words/chapters, POV distribution, arc/episode breakdown, longest/shortest chapters
+  - Examples:
+    - No filters: Overall timeline statistics
+    - `arc: "arc1"`: Statistics for specific arc
+    - `arc: "arc1", episode: 1`: Statistics for specific episode
+    - `pov: "Alice"`: Statistics for specific POV across timeline
+
+### RAG (Semantic Search)
+- **`rag-index`** - Index chapters into vector database for semantic search
+  - Input: optional: `arc`, `episode` (to index specific content)
+  - Output: Number of chapters indexed
+  
+- **`rag-search`** - Semantic search across timeline content
+  - Input: `query`, optional: `arc`, `pov`, `maxResults`
+  - Output: Relevant chapters with similarity scores and previews
+  
+- **`rag-context`** - Retrieve relevant context for AI interactions
+  - Input: `query`, optional: `arc`, `pov`, `maxChapters`
+  - Output: Full chapter content for AI context
 
 ## Development
 
@@ -73,10 +132,23 @@ npm run lint:fix
 ### Tech Stack
 
 - **Language**: TypeScript (strict mode)
-- **Testing**: Vitest
+- **Testing**: Vitest (97%+ coverage)
 - **Linting**: Biome
 - **Build**: TypeScript compiler
 
+### Architecture
+
+- **MCP Protocol**: Standard Model Context Protocol implementation
+- **Database**: SQLite via @echoes-io/tracker (singleton pattern)
+- **Validation**: Zod schemas for type-safe inputs
+- **Testing**: Comprehensive unit and integration tests
+- **Environment**: Uses `ECHOES_TIMELINE` env var for timeline context
+
+## Roadmap
+
+### Planned Features
+- **Book generation** - LaTeX/PDF compilation tools for creating publishable books from timeline content
+
 ## License
 
 MIT

package/lib/server.d.ts

@@ -1,5 +1,7 @@
+import { RAGSystem } from '@echoes-io/rag';
+import { Tracker } from '@echoes-io/tracker';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-export declare function createServer(): Server<{
+export declare function createServer(tracker: Tracker, rag: RAGSystem): Server<{
     method: string;
     params?: {
         [x: string]: unknown;

package/lib/server.js

@@ -1,12 +1,16 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+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 { chapterDelete, chapterDeleteSchema, chapterInfo, chapterInfoSchema, chapterInsert, chapterInsertSchema, chapterRefresh, chapterRefreshSchema, episodeInfo, episodeInfoSchema, episodeUpdate, episodeUpdateSchema, 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'));
-export function createServer() {
+export function createServer(tracker, rag) {
     const server = new Server({
         name: pkg.name,
         version: pkg.version,
@@ -17,16 +21,119 @@ export function createServer() {
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         return {
-            tools: [],
+            tools: [
+                {
+                    name: 'words-count',
+                    description: 'Count words and text statistics in a markdown file',
+                    inputSchema: zodToJsonSchema(wordsCountSchema),
+                },
+                {
+                    name: 'chapter-info',
+                    description: 'Extract chapter metadata, content preview, and statistics',
+                    inputSchema: zodToJsonSchema(chapterInfoSchema),
+                },
+                {
+                    name: 'episode-info',
+                    description: 'Get episode information and list of chapters',
+                    inputSchema: zodToJsonSchema(episodeInfoSchema),
+                },
+                {
+                    name: 'episode-update',
+                    description: 'Update episode metadata (description, title, slug)',
+                    inputSchema: zodToJsonSchema(episodeUpdateSchema),
+                },
+                {
+                    name: 'chapter-refresh',
+                    description: 'Refresh chapter metadata and statistics from file',
+                    inputSchema: zodToJsonSchema(chapterRefreshSchema),
+                },
+                {
+                    name: 'chapter-delete',
+                    description: 'Delete chapter from database and optionally from filesystem',
+                    inputSchema: zodToJsonSchema(chapterDeleteSchema),
+                },
+                {
+                    name: 'chapter-insert',
+                    description: 'Insert new chapter and automatically renumber subsequent chapters',
+                    inputSchema: zodToJsonSchema(chapterInsertSchema),
+                },
+                {
+                    name: 'timeline-sync',
+                    description: 'Synchronize timeline content with database',
+                    inputSchema: zodToJsonSchema(timelineSyncSchema),
+                },
+                {
+                    name: 'stats',
+                    description: 'Get statistics for timeline, arc, episode, or POV',
+                    inputSchema: zodToJsonSchema(statsSchema),
+                },
+                {
+                    name: 'rag-index',
+                    description: 'Index chapters into RAG vector database for semantic search',
+                    inputSchema: zodToJsonSchema(ragIndexSchema),
+                },
+                {
+                    name: 'rag-search',
+                    description: 'Semantic search across timeline content',
+                    inputSchema: zodToJsonSchema(ragSearchSchema),
+                },
+                {
+                    name: 'rag-context',
+                    description: 'Retrieve relevant context for AI interactions',
+                    inputSchema: zodToJsonSchema(ragContextSchema),
+                },
+            ],
         };
     });
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        throw new Error(`Unknown tool: ${request.params.name}`);
+        const { name, arguments: args } = request.params;
+        switch (name) {
+            case 'words-count':
+                return await wordsCount(wordsCountSchema.parse(args));
+            case 'chapter-info':
+                return await chapterInfo(chapterInfoSchema.parse(args), tracker);
+            case 'chapter-refresh':
+                return await chapterRefresh(chapterRefreshSchema.parse(args), tracker);
+            case 'chapter-delete':
+                return await chapterDelete(chapterDeleteSchema.parse(args), tracker);
+            case 'chapter-insert':
+                return await chapterInsert(chapterInsertSchema.parse(args), tracker);
+            case 'episode-info':
+                return await episodeInfo(episodeInfoSchema.parse(args), tracker);
+            case 'episode-update':
+                return await episodeUpdate(episodeUpdateSchema.parse(args), tracker);
+            case 'timeline-sync':
+                return await timelineSync(timelineSyncSchema.parse(args), tracker);
+            case 'stats':
+                return await stats(statsSchema.parse(args), tracker);
+            case 'rag-index':
+                return await ragIndex(ragIndexSchema.parse(args), tracker, rag);
+            case 'rag-search':
+                return await ragSearch(ragSearchSchema.parse(args), rag);
+            case 'rag-context':
+                return await ragContext(ragContextSchema.parse(args), rag);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
     });
     return server;
 }
 export async function runServer() {
-    const server = createServer();
+    // Initialize tracker database in appropriate location
+    const dbPath = process.env.NODE_ENV === 'test' ? ':memory:' : './tracker.db';
+    const tracker = new Tracker(dbPath);
+    await tracker.init();
+    console.error(`Tracker database initialized: ${dbPath}`);
+    // Initialize RAG system
+    const chromaUrl = process.env.ECHOES_CHROMA_URL || (process.env.NODE_ENV === 'test' ? ':memory:' : './rag_data');
+    const provider = (process.env.ECHOES_RAG_PROVIDER || 'e5-small');
+    const rag = new RAGSystem({
+        provider,
+        chromaUrl,
+        geminiApiKey: process.env.ECHOES_GEMINI_API_KEY,
+    });
+    console.error(`RAG system initialized: ${chromaUrl} (provider: ${provider})`);
+    const server = createServer(tracker, rag);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('Echoes MCP Server running on stdio');

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

@@ -0,0 +1,24 @@
+import type { Tracker } from '@echoes-io/tracker';
+import { z } from 'zod';
+export declare const chapterDeleteSchema: z.ZodObject<{
+    arc: z.ZodString;
+    episode: z.ZodNumber;
+    chapter: z.ZodNumber;
+    file: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    arc: string;
+    episode: number;
+    chapter: number;
+    file?: string | undefined;
+}, {
+    arc: string;
+    episode: number;
+    chapter: number;
+    file?: string | undefined;
+}>;
+export declare function chapterDelete(args: z.infer<typeof chapterDeleteSchema>, tracker: Tracker): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/lib/tools/chapter-delete.js

@@ -0,0 +1,49 @@
+import { unlinkSync } from 'node:fs';
+import { z } from 'zod';
+import { getTimeline } from '../utils.js';
+export const chapterDeleteSchema = z.object({
+    arc: z.string().describe('Arc name'),
+    episode: z.number().describe('Episode number'),
+    chapter: z.number().describe('Chapter number'),
+    file: z.string().optional().describe('Path to markdown file to delete from filesystem'),
+});
+export async function chapterDelete(args, tracker) {
+    try {
+        const timeline = getTimeline();
+        const existing = await tracker.getChapter(timeline, args.arc, args.episode, args.chapter);
+        if (!existing) {
+            throw new Error(`Chapter not found: ${timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
+        }
+        await tracker.deleteChapter(timeline, args.arc, args.episode, args.chapter);
+        let fileDeleted = false;
+        if (args.file) {
+            unlinkSync(args.file);
+            fileDeleted = true;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        timeline,
+                        arc: args.arc,
+                        episode: args.episode,
+                        chapter: args.chapter,
+                        deleted: {
+                            pov: existing.pov,
+                            title: existing.title,
+                            words: existing.words,
+                        },
+                        fileDeleted,
+                        message: fileDeleted
+                            ? 'Chapter deleted from database and filesystem'
+                            : 'Chapter deleted from database only',
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to delete chapter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { Tracker } from '@echoes-io/tracker';
+import { z } from 'zod';
+export declare const chapterInfoSchema: z.ZodObject<{
+    arc: z.ZodString;
+    episode: z.ZodNumber;
+    chapter: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    arc: string;
+    episode: number;
+    chapter: number;
+}, {
+    arc: string;
+    episode: number;
+    chapter: number;
+}>;
+export declare function chapterInfo(args: z.infer<typeof chapterInfoSchema>, tracker: Tracker): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/lib/tools/chapter-info.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { getTimeline } from '../utils.js';
+export const chapterInfoSchema = z.object({
+    arc: z.string().describe('Arc name'),
+    episode: z.number().describe('Episode number'),
+    chapter: z.number().describe('Chapter number'),
+});
+export async function chapterInfo(args, tracker) {
+    try {
+        const timeline = getTimeline();
+        const chapter = await tracker.getChapter(timeline, args.arc, args.episode, args.chapter);
+        if (!chapter) {
+            throw new Error(`Chapter not found: ${timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        timeline,
+                        arc: args.arc,
+                        episode: args.episode,
+                        chapter: args.chapter,
+                        metadata: {
+                            pov: chapter.pov,
+                            title: chapter.title,
+                            date: chapter.date,
+                            excerpt: chapter.excerpt,
+                            location: chapter.location,
+                            outfit: chapter.outfit,
+                            kink: chapter.kink,
+                        },
+                        stats: {
+                            words: chapter.words,
+                            characters: chapter.characters,
+                            charactersNoSpaces: chapter.charactersNoSpaces,
+                            paragraphs: chapter.paragraphs,
+                            sentences: chapter.sentences,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get chapter info: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

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

@@ -0,0 +1,42 @@
+import type { Tracker } from '@echoes-io/tracker';
+import { z } from 'zod';
+export declare const chapterInsertSchema: z.ZodObject<{
+    arc: z.ZodString;
+    episode: z.ZodNumber;
+    after: z.ZodNumber;
+    pov: z.ZodString;
+    title: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    outfit: z.ZodOptional<z.ZodString>;
+    kink: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    arc: string;
+    episode: number;
+    after: number;
+    pov: string;
+    title: string;
+    file?: string | undefined;
+    excerpt?: string | undefined;
+    location?: string | undefined;
+    outfit?: string | undefined;
+    kink?: string | undefined;
+}, {
+    arc: string;
+    episode: number;
+    after: number;
+    pov: string;
+    title: string;
+    file?: string | undefined;
+    excerpt?: string | undefined;
+    location?: string | undefined;
+    outfit?: string | undefined;
+    kink?: string | undefined;
+}>;
+export declare function chapterInsert(args: z.infer<typeof chapterInsertSchema>, tracker: Tracker): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/lib/tools/chapter-insert.js

@@ -0,0 +1,99 @@
+import { getTextStats, parseMarkdown } from '@echoes-io/utils';
+import { z } from 'zod';
+import { getTimeline } from '../utils.js';
+export const chapterInsertSchema = z.object({
+    arc: z.string().describe('Arc name'),
+    episode: z.number().describe('Episode number'),
+    after: z.number().describe('Insert after this chapter number'),
+    pov: z.string().describe('Point of view character'),
+    title: z.string().describe('Chapter title'),
+    excerpt: z.string().optional().describe('Chapter excerpt'),
+    location: z.string().optional().describe('Chapter location'),
+    outfit: z.string().optional().describe('Character outfit'),
+    kink: z.string().optional().describe('Content tags'),
+    file: z.string().optional().describe('Path to markdown file to read content from'),
+});
+export async function chapterInsert(args, tracker) {
+    try {
+        const timeline = getTimeline();
+        const episode = await tracker.getEpisode(timeline, args.arc, args.episode);
+        if (!episode) {
+            throw new Error(`Episode not found: ${timeline}/${args.arc}/ep${args.episode}`);
+        }
+        const existingChapters = await tracker.getChapters(timeline, args.arc, args.episode);
+        const newChapterNumber = args.after + 1;
+        const chaptersToRenumber = existingChapters.filter((ch) => ch.number >= newChapterNumber);
+        for (const chapter of chaptersToRenumber) {
+            try {
+                await tracker.updateChapter(timeline, args.arc, args.episode, chapter.number, {
+                    number: chapter.number + 1,
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to renumber chapter ${chapter.number}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        let words = 0;
+        let characters = 0;
+        let charactersNoSpaces = 0;
+        let paragraphs = 0;
+        let sentences = 0;
+        if (args.file) {
+            const { readFileSync } = await import('node:fs');
+            const content = readFileSync(args.file, 'utf-8');
+            const { content: markdownContent } = parseMarkdown(content);
+            const stats = getTextStats(markdownContent);
+            words = stats.words;
+            characters = stats.characters;
+            charactersNoSpaces = stats.charactersNoSpaces;
+            paragraphs = stats.paragraphs;
+            sentences = stats.sentences;
+        }
+        await tracker.createChapter({
+            timelineName: timeline,
+            arcName: args.arc,
+            episodeNumber: args.episode,
+            partNumber: 1,
+            number: newChapterNumber,
+            pov: args.pov,
+            title: args.title,
+            date: new Date(),
+            excerpt: args.excerpt || '',
+            location: args.location || '',
+            outfit: args.outfit || '',
+            kink: args.kink || '',
+            words,
+            characters,
+            charactersNoSpaces,
+            paragraphs,
+            sentences,
+            readingTimeMinutes: Math.ceil(words / 200),
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        timeline,
+                        arc: args.arc,
+                        episode: args.episode,
+                        inserted: {
+                            chapter: newChapterNumber,
+                            pov: args.pov,
+                            title: args.title,
+                            words,
+                        },
+                        renumbered: chaptersToRenumber.map((ch) => ({
+                            oldNumber: ch.number,
+                            newNumber: ch.number + 1,
+                            title: ch.title,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to insert chapter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { Tracker } from '@echoes-io/tracker';
+import { z } from 'zod';
+export declare const chapterRefreshSchema: z.ZodObject<{
+    file: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+}, {
+    file: string;
+}>;
+export declare function chapterRefresh(args: z.infer<typeof chapterRefreshSchema>, tracker: Tracker): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/lib/tools/chapter-refresh.js

@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs';
+import { getTextStats, parseMarkdown } from '@echoes-io/utils';
+import { z } from 'zod';
+import { getTimeline } from '../utils.js';
+export const chapterRefreshSchema = z.object({
+    file: z.string().describe('Path to chapter markdown file'),
+});
+export async function chapterRefresh(args, tracker) {
+    try {
+        const content = readFileSync(args.file, 'utf-8');
+        const { metadata, content: markdownContent } = parseMarkdown(content);
+        const stats = getTextStats(markdownContent);
+        const timeline = getTimeline();
+        const arc = metadata.arc;
+        const episode = metadata.episode;
+        const chapter = metadata.chapter;
+        if (!arc || !episode || !chapter) {
+            throw new Error('Missing required metadata: arc, episode, or chapter');
+        }
+        const existing = await tracker.getChapter(timeline, arc, episode, chapter);
+        if (!existing) {
+            throw new Error(`Chapter not found in database: ${timeline}/${arc}/ep${episode}/ch${chapter}`);
+        }
+        const chapterData = {
+            timelineName: timeline,
+            arcName: arc,
+            episodeNumber: episode,
+            partNumber: metadata.part || 1,
+            number: chapter,
+            pov: metadata.pov || 'Unknown',
+            title: metadata.title || 'Untitled',
+            date: new Date(metadata.date || Date.now()),
+            excerpt: metadata.excerpt || '',
+            location: metadata.location || '',
+            outfit: metadata.outfit || '',
+            kink: metadata.kink || '',
+            words: stats.words,
+            characters: stats.characters,
+            charactersNoSpaces: stats.charactersNoSpaces,
+            paragraphs: stats.paragraphs,
+            sentences: stats.sentences,
+            readingTimeMinutes: Math.ceil(stats.words / 200),
+        };
+        await tracker.updateChapter(timeline, arc, episode, chapter, chapterData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        file: args.file,
+                        timeline,
+                        arc,
+                        episode,
+                        chapter,
+                        updated: {
+                            metadata: {
+                                pov: chapterData.pov,
+                                title: chapterData.title,
+                                date: chapterData.date,
+                                excerpt: chapterData.excerpt,
+                                location: chapterData.location,
+                            },
+                            stats: {
+                                words: stats.words,
+                                characters: stats.characters,
+                                paragraphs: stats.paragraphs,
+                                sentences: stats.sentences,
+                                readingTimeMinutes: chapterData.readingTimeMinutes,
+                            },
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to refresh chapter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { Tracker } from '@echoes-io/tracker';
+import { z } from 'zod';
+export declare const episodeInfoSchema: z.ZodObject<{
+    arc: z.ZodString;
+    episode: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    arc: string;
+    episode: number;
+}, {
+    arc: string;
+    episode: number;
+}>;
+export declare function episodeInfo(args: z.infer<typeof episodeInfoSchema>, tracker: Tracker): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;