@echoes-io/mcp-server 1.3.3 → 1.4.0

package/README.md

@@ -15,10 +15,7 @@ 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"],
-      "env": {
-        "ECHOES_TIMELINE": "your-timeline-name"
-      }
+      "args": ["-y", "@echoes-io/mcp-server"]
     }
   }
 }
@@ -38,7 +35,6 @@ Then configure:
     "echoes": {
       "command": "echoes-mcp-server",
       "env": {
-        "ECHOES_TIMELINE": "your-timeline-name",
         "ECHOES_RAG_PROVIDER": "e5-small",
         "ECHOES_RAG_DB_PATH": "./rag_data.db"
       }
@@ -47,8 +43,6 @@ Then configure:
 }
 ```
 
-**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
@@ -56,7 +50,7 @@ Then configure:
 
 ## Available Tools
 
-All tools operate on the timeline specified by the `ECHOES_TIMELINE` environment variable.
+All tools require a `timeline` parameter to specify which timeline to operate on.
 
 ### Content Operations
 - **`words-count`** - Count words and text statistics in markdown files
@@ -69,7 +63,7 @@ All tools operate on the timeline specified by the `ECHOES_TIMELINE` environment
   - 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`
+  - Input: `arc`, `episode`, `after`, `pov`, `title`, optional: `summary`, `location`, `outfit`, `kink`, `file`
   
 - **`chapter-delete`** - Delete chapter from database and optionally from filesystem
   - Input: `arc`, `episode`, `chapter`, optional: `file` (to delete from filesystem)
@@ -150,7 +144,7 @@ npm run lint:format
 - **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
+- **Timeline Parameter**: All tools accept timeline as a required parameter
 
 ## License
 

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

@@ -1,15 +1,18 @@
 import { z } from 'zod';
 export declare const bookGenerateSchema: z.ZodObject<{
+    timeline: z.ZodString;
     contentPath: z.ZodString;
     outputPath: z.ZodString;
     episodes: z.ZodOptional<z.ZodString>;
     format: z.ZodOptional<z.ZodEnum<["a4", "a5"]>>;
 }, "strip", z.ZodTypeAny, {
+    timeline: string;
     contentPath: string;
     outputPath: string;
     episodes?: string | undefined;
     format?: "a4" | "a5" | undefined;
 }, {
+    timeline: string;
     contentPath: string;
     outputPath: string;
     episodes?: string | undefined;

package/lib/tools/book-generate.js

@@ -1,7 +1,7 @@
 import { generateBook } from '@echoes-io/books-generator';
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const bookGenerateSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     contentPath: z.string().describe('Path to timeline content folder'),
     outputPath: z.string().describe('Output PDF file path'),
     episodes: z.string().optional().describe('Comma-separated episode numbers (e.g., "1,2,3")'),
@@ -9,11 +9,10 @@ export const bookGenerateSchema = z.object({
 });
 export async function bookGenerate(args) {
     try {
-        const timeline = getTimeline();
         await generateBook({
             contentPath: args.contentPath,
             outputPath: args.outputPath,
-            timeline,
+            timeline: args.timeline,
             episodes: args.episodes,
             format: args.format || 'a4',
         });
@@ -23,7 +22,7 @@ export async function bookGenerate(args) {
                     type: 'text',
                     text: JSON.stringify({
                         success: true,
-                        timeline,
+                        timeline: args.timeline,
                         outputPath: args.outputPath,
                         episodes: args.episodes || 'all',
                         format: args.format || 'a4',

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

@@ -1,16 +1,19 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const chapterDeleteSchema: z.ZodObject<{
+    timeline: z.ZodString;
     arc: z.ZodString;
     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;

package/lib/tools/chapter-delete.js

@@ -1,7 +1,7 @@
 import { unlinkSync } from 'node:fs';
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const chapterDeleteSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     arc: z.string().describe('Arc name'),
     episode: z.number().describe('Episode number'),
     chapter: z.number().describe('Chapter number'),
@@ -9,12 +9,11 @@ export const chapterDeleteSchema = z.object({
 });
 export async function chapterDelete(args, tracker) {
     try {
-        const timeline = getTimeline();
-        const existing = await tracker.getChapter(timeline, args.arc, args.episode, args.chapter);
+        const existing = await tracker.getChapter(args.timeline, args.arc, args.episode, args.chapter);
         if (!existing) {
-            throw new Error(`Chapter not found: ${timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
+            throw new Error(`Chapter not found: ${args.timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
         }
-        await tracker.deleteChapter(timeline, args.arc, args.episode, args.chapter);
+        await tracker.deleteChapter(args.timeline, args.arc, args.episode, args.chapter);
         let fileDeleted = false;
         if (args.file) {
             unlinkSync(args.file);
@@ -25,7 +24,7 @@ export async function chapterDelete(args, tracker) {
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc,
                         episode: args.episode,
                         chapter: args.chapter,

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

@@ -1,14 +1,17 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const chapterInfoSchema: z.ZodObject<{
+    timeline: z.ZodString;
     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;

package/lib/tools/chapter-info.js

@@ -1,23 +1,22 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const chapterInfoSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     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);
+        const chapter = await tracker.getChapter(args.timeline, args.arc, args.episode, args.chapter);
         if (!chapter) {
-            throw new Error(`Chapter not found: ${timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
+            throw new Error(`Chapter not found: ${args.timeline}/${args.arc}/ep${args.episode}/ch${args.chapter}`);
         }
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc,
                         episode: args.episode,
                         chapter: args.chapter,
@@ -25,7 +24,7 @@ export async function chapterInfo(args, tracker) {
                             pov: chapter.pov,
                             title: chapter.title,
                             date: chapter.date,
-                            excerpt: chapter.excerpt,
+                            summary: chapter.summary,
                             location: chapter.location,
                             outfit: chapter.outfit,
                             kink: chapter.kink,

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

@@ -1,35 +1,38 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const chapterInsertSchema: z.ZodObject<{
+    timeline: z.ZodString;
     arc: z.ZodString;
     episode: z.ZodNumber;
     after: z.ZodNumber;
     pov: z.ZodString;
     title: z.ZodString;
-    excerpt: z.ZodOptional<z.ZodString>;
+    summary: 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, {
+    timeline: string;
     arc: string;
     episode: number;
     after: number;
     pov: string;
     title: string;
     file?: string | undefined;
-    excerpt?: 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;
-    excerpt?: string | undefined;
+    summary?: string | undefined;
     location?: string | undefined;
     outfit?: string | undefined;
     kink?: string | undefined;

package/lib/tools/chapter-insert.js

@@ -1,13 +1,13 @@
 import { getTextStats, parseMarkdown } from '@echoes-io/utils';
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const chapterInsertSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     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'),
+    summary: z.string().optional().describe('Chapter summary'),
     location: z.string().optional().describe('Chapter location'),
     outfit: z.string().optional().describe('Character outfit'),
     kink: z.string().optional().describe('Content tags'),
@@ -15,17 +15,16 @@ export const chapterInsertSchema = z.object({
 });
 export async function chapterInsert(args, tracker) {
     try {
-        const timeline = getTimeline();
-        const episode = await tracker.getEpisode(timeline, args.arc, args.episode);
+        const episode = await tracker.getEpisode(args.timeline, args.arc, args.episode);
         if (!episode) {
-            throw new Error(`Episode not found: ${timeline}/${args.arc}/ep${args.episode}`);
+            throw new Error(`Episode not found: ${args.timeline}/${args.arc}/ep${args.episode}`);
         }
-        const existingChapters = await tracker.getChapters(timeline, args.arc, args.episode);
+        const existingChapters = await tracker.getChapters(args.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, {
+                await tracker.updateChapter(args.timeline, args.arc, args.episode, chapter.number, {
                     number: chapter.number + 1,
                 });
             }
@@ -49,16 +48,21 @@ export async function chapterInsert(args, tracker) {
             paragraphs = stats.paragraphs;
             sentences = stats.sentences;
         }
-        await tracker.createChapter({
-            timelineName: timeline,
+        const chapterData = {
+            timelineName: args.timeline,
             arcName: args.arc,
             episodeNumber: args.episode,
             partNumber: 1,
             number: newChapterNumber,
+            timeline: args.timeline,
+            arc: args.arc,
+            episode: args.episode,
+            part: 1,
+            chapter: newChapterNumber,
             pov: args.pov,
             title: args.title,
-            date: new Date(),
-            excerpt: args.excerpt || '',
+            date: new Date().toISOString(),
+            summary: args.summary || '',
             location: args.location || '',
             outfit: args.outfit || '',
             kink: args.kink || '',
@@ -68,13 +72,14 @@ export async function chapterInsert(args, tracker) {
             paragraphs,
             sentences,
             readingTimeMinutes: Math.ceil(words / 200),
-        });
+        };
+        await tracker.createChapter(chapterData);
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc,
                         episode: args.episode,
                         inserted: {

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

@@ -1,10 +1,13 @@
 import type { Tracker } from '@echoes-io/tracker';
 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;
 }>;
 export declare function chapterRefresh(args: z.infer<typeof chapterRefreshSchema>, tracker: Tracker): Promise<{

package/lib/tools/chapter-refresh.js

@@ -1,8 +1,8 @@
 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({
+    timeline: z.string().describe('Timeline name'),
     file: z.string().describe('Path to chapter markdown file'),
 });
 export async function chapterRefresh(args, tracker) {
@@ -10,27 +10,26 @@ export async function chapterRefresh(args, tracker) {
         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);
+        const existing = await tracker.getChapter(args.timeline, arc, episode, chapter);
         if (!existing) {
-            throw new Error(`Chapter not found in database: ${timeline}/${arc}/ep${episode}/ch${chapter}`);
+            throw new Error(`Chapter not found in database: ${args.timeline}/${arc}/ep${episode}/ch${chapter}`);
         }
         const chapterData = {
-            timelineName: timeline,
+            timelineName: args.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 || '',
+            date: new Date(metadata.date || Date.now()).toISOString(),
+            summary: metadata.summary || '',
             location: metadata.location || '',
             outfit: metadata.outfit || '',
             kink: metadata.kink || '',
@@ -41,14 +40,14 @@ export async function chapterRefresh(args, tracker) {
             sentences: stats.sentences,
             readingTimeMinutes: Math.ceil(stats.words / 200),
         };
-        await tracker.updateChapter(timeline, arc, episode, chapter, chapterData);
+        await tracker.updateChapter(args.timeline, arc, episode, chapter, chapterData);
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
                         file: args.file,
-                        timeline,
+                        timeline: args.timeline,
                         arc,
                         episode,
                         chapter,
@@ -57,7 +56,7 @@ export async function chapterRefresh(args, tracker) {
                                 pov: chapterData.pov,
                                 title: chapterData.title,
                                 date: chapterData.date,
-                                excerpt: chapterData.excerpt,
+                                summary: chapterData.summary,
                                 location: chapterData.location,
                             },
                             stats: {

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

@@ -1,12 +1,15 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 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;
 }>;

package/lib/tools/episode-info.js

@@ -1,23 +1,22 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const episodeInfoSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     arc: z.string().describe('Arc name'),
     episode: z.number().describe('Episode number'),
 });
 export async function episodeInfo(args, tracker) {
     try {
-        const timeline = getTimeline();
-        const episode = await tracker.getEpisode(timeline, args.arc, args.episode);
+        const episode = await tracker.getEpisode(args.timeline, args.arc, args.episode);
         if (!episode) {
-            throw new Error(`Episode not found: ${timeline}/${args.arc}/ep${args.episode}`);
+            throw new Error(`Episode not found: ${args.timeline}/${args.arc}/ep${args.episode}`);
         }
-        const chapters = await tracker.getChapters(timeline, args.arc, args.episode);
+        const chapters = await tracker.getChapters(args.timeline, args.arc, args.episode);
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc,
                         episodeInfo: {
                             number: episode.number,

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

@@ -1,18 +1,21 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const episodeUpdateSchema: z.ZodObject<{
+    timeline: z.ZodString;
     arc: z.ZodString;
     episode: z.ZodNumber;
     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;

package/lib/tools/episode-update.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const episodeUpdateSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     arc: z.string().describe('Arc name'),
     episode: z.number().describe('Episode number'),
     description: z.string().optional().describe('Episode description'),
@@ -9,10 +9,9 @@ export const episodeUpdateSchema = z.object({
 });
 export async function episodeUpdate(args, tracker) {
     try {
-        const timeline = getTimeline();
-        const existing = await tracker.getEpisode(timeline, args.arc, args.episode);
+        const existing = await tracker.getEpisode(args.timeline, args.arc, args.episode);
         if (!existing) {
-            throw new Error(`Episode not found: ${timeline}/${args.arc}/ep${args.episode}`);
+            throw new Error(`Episode not found: ${args.timeline}/${args.arc}/ep${args.episode}`);
         }
         const updateData = {};
         if (args.description !== undefined)
@@ -21,13 +20,13 @@ export async function episodeUpdate(args, tracker) {
             updateData.title = args.title;
         if (args.slug !== undefined)
             updateData.slug = args.slug;
-        await tracker.updateEpisode(timeline, args.arc, args.episode, updateData);
+        await tracker.updateEpisode(args.timeline, args.arc, args.episode, updateData);
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc,
                         episode: args.episode,
                         updated: updateData,

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

@@ -1,16 +1,19 @@
 import type { RAGSystem } from '@echoes-io/rag';
 import { z } from 'zod';
 export declare const ragContextSchema: z.ZodObject<{
+    timeline: z.ZodString;
     query: z.ZodString;
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxChapters: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    timeline: string;
     query: string;
     arc?: string | undefined;
     pov?: string | undefined;
     maxChapters?: number | undefined;
 }, {
+    timeline: string;
     query: string;
     arc?: string | undefined;
     pov?: string | undefined;

package/lib/tools/rag-context.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const ragContextSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     query: z.string().describe('Context query'),
     arc: z.string().optional().describe('Filter by arc name'),
     pov: z.string().optional().describe('Filter by POV character'),
@@ -8,10 +8,9 @@ export const ragContextSchema = z.object({
 });
 export async function ragContext(args, rag) {
     try {
-        const timeline = getTimeline();
         const results = await rag.getContext({
             query: args.query,
-            timeline,
+            timeline: args.timeline,
             arc: args.arc,
             pov: args.pov,
             maxChapters: args.maxChapters,
@@ -22,7 +21,7 @@ export async function ragContext(args, rag) {
                     type: 'text',
                     text: JSON.stringify({
                         query: args.query,
-                        timeline,
+                        timeline: args.timeline,
                         filters: {
                             arc: args.arc || null,
                             pov: args.pov || null,

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

@@ -2,14 +2,17 @@ import type { RAGSystem } from '@echoes-io/rag';
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const ragIndexSchema: z.ZodObject<{
+    timeline: z.ZodString;
     contentPath: z.ZodOptional<z.ZodString>;
     arc: z.ZodOptional<z.ZodString>;
     episode: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    timeline: string;
     contentPath?: string | undefined;
     arc?: string | undefined;
     episode?: number | undefined;
 }, {
+    timeline: string;
     contentPath?: string | undefined;
     arc?: string | undefined;
     episode?: number | undefined;

package/lib/tools/rag-index.js

@@ -2,33 +2,32 @@ import { readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseMarkdown } from '@echoes-io/utils';
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const ragIndexSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     contentPath: z.string().optional().describe('Path to content directory (required for indexing)'),
     arc: z.string().optional().describe('Index specific arc only'),
     episode: z.number().optional().describe('Index specific episode only (requires arc)'),
 });
 export async function ragIndex(args, tracker, rag) {
     try {
-        const timeline = getTimeline();
         let chapters = [];
         // Get chapters based on filters
         if (args.arc && args.episode) {
-            chapters = await tracker.getChapters(timeline, args.arc, args.episode);
+            chapters = await tracker.getChapters(args.timeline, args.arc, args.episode);
         }
         else if (args.arc) {
-            const episodes = await tracker.getEpisodes(timeline, args.arc);
+            const episodes = await tracker.getEpisodes(args.timeline, args.arc);
             for (const ep of episodes) {
-                const epChapters = await tracker.getChapters(timeline, args.arc, ep.number);
+                const epChapters = await tracker.getChapters(args.timeline, args.arc, ep.number);
                 chapters.push(...epChapters);
             }
         }
         else {
-            const arcs = await tracker.getArcs(timeline);
+            const arcs = await tracker.getArcs(args.timeline);
             for (const arc of arcs) {
-                const episodes = await tracker.getEpisodes(timeline, arc.name);
+                const episodes = await tracker.getEpisodes(args.timeline, arc.name);
                 for (const ep of episodes) {
-                    const epChapters = await tracker.getChapters(timeline, arc.name, ep.number);
+                    const epChapters = await tracker.getChapters(args.timeline, arc.name, ep.number);
                     chapters.push(...epChapters);
                 }
             }
@@ -85,7 +84,7 @@ export async function ragIndex(args, tracker, rag) {
                     type: 'text',
                     text: JSON.stringify({
                         indexed: embeddingChapters.length,
-                        timeline,
+                        timeline: args.timeline,
                         arc: args.arc || 'all',
                         episode: args.episode || 'all',
                     }, null, 2),

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

@@ -1,16 +1,19 @@
 import type { RAGSystem } from '@echoes-io/rag';
 import { z } from 'zod';
 export declare const ragSearchSchema: z.ZodObject<{
+    timeline: z.ZodString;
     query: z.ZodString;
     arc: z.ZodOptional<z.ZodString>;
     pov: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    timeline: string;
     query: string;
     arc?: string | undefined;
     pov?: string | undefined;
     maxResults?: number | undefined;
 }, {
+    timeline: string;
     query: string;
     arc?: string | undefined;
     pov?: string | undefined;

package/lib/tools/rag-search.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const ragSearchSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     query: z.string().describe('Search query'),
     arc: z.string().optional().describe('Filter by arc name'),
     pov: z.string().optional().describe('Filter by POV character'),
@@ -8,9 +8,8 @@ export const ragSearchSchema = z.object({
 });
 export async function ragSearch(args, rag) {
     try {
-        const timeline = getTimeline();
         const results = await rag.search(args.query, {
-            timeline,
+            timeline: args.timeline,
             arc: args.arc,
             pov: args.pov,
             maxResults: args.maxResults,
@@ -21,7 +20,7 @@ export async function ragSearch(args, rag) {
                     type: 'text',
                     text: JSON.stringify({
                         query: args.query,
-                        timeline,
+                        timeline: args.timeline,
                         filters: {
                             arc: args.arc || null,
                             pov: args.pov || null,

package/lib/tools/stats.d.ts

@@ -1,14 +1,17 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const statsSchema: z.ZodObject<{
+    timeline: z.ZodString;
     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;

package/lib/tools/stats.js

@@ -1,31 +1,30 @@
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const statsSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     arc: z.string().optional().describe('Filter by arc name'),
     episode: z.number().optional().describe('Filter by episode number'),
     pov: z.string().optional().describe('Filter by POV character'),
 });
 export async function stats(args, tracker) {
     try {
-        const timeline = getTimeline();
         let chapters = [];
         // Get chapters based on filters
         if (args.arc && args.episode) {
-            chapters = await tracker.getChapters(timeline, args.arc, args.episode);
+            chapters = await tracker.getChapters(args.timeline, args.arc, args.episode);
         }
         else if (args.arc) {
-            const episodes = await tracker.getEpisodes(timeline, args.arc);
+            const episodes = await tracker.getEpisodes(args.timeline, args.arc);
             for (const ep of episodes) {
-                const epChapters = await tracker.getChapters(timeline, args.arc, ep.number);
+                const epChapters = await tracker.getChapters(args.timeline, args.arc, ep.number);
                 chapters.push(...epChapters);
             }
         }
         else {
-            const arcs = await tracker.getArcs(timeline);
+            const arcs = await tracker.getArcs(args.timeline);
             for (const arc of arcs) {
-                const episodes = await tracker.getEpisodes(timeline, arc.name);
+                const episodes = await tracker.getEpisodes(args.timeline, arc.name);
                 for (const ep of episodes) {
-                    const epChapters = await tracker.getChapters(timeline, arc.name, ep.number);
+                    const epChapters = await tracker.getChapters(args.timeline, arc.name, ep.number);
                     chapters.push(...epChapters);
                 }
             }
@@ -70,7 +69,7 @@ export async function stats(args, tracker) {
             }
         }
         const result = {
-            timeline,
+            timeline: args.timeline,
             filters: {
                 arc: args.arc || null,
                 episode: args.episode || null,

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

@@ -1,10 +1,13 @@
 import type { Tracker } from '@echoes-io/tracker';
 import { z } from 'zod';
 export declare const timelineSyncSchema: z.ZodObject<{
+    timeline: z.ZodString;
     contentPath: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    timeline: string;
     contentPath: string;
 }, {
+    timeline: string;
     contentPath: string;
 }>;
 export declare function timelineSync(args: z.infer<typeof timelineSyncSchema>, tracker: Tracker): Promise<{

package/lib/tools/timeline-sync.js

@@ -2,19 +2,18 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { getTextStats, parseMarkdown } from '@echoes-io/utils';
 import { z } from 'zod';
-import { getTimeline } from '../utils.js';
 export const timelineSyncSchema = z.object({
+    timeline: z.string().describe('Timeline name'),
     contentPath: z.string().describe('Path to content directory'),
 });
 export async function timelineSync(args, tracker) {
     try {
-        const timeline = getTimeline();
         let added = 0, updated = 0, deleted = 0, errors = 0;
-        let timelineRecord = await tracker.getTimeline(timeline);
+        let timelineRecord = await tracker.getTimeline(args.timeline);
         if (!timelineRecord) {
             timelineRecord = await tracker.createTimeline({
-                name: timeline,
-                description: `Timeline ${timeline}`,
+                name: args.timeline,
+                description: `Timeline ${args.timeline}`,
             });
             added++;
         }
@@ -23,10 +22,10 @@ export async function timelineSync(args, tracker) {
             .map((entry) => entry.name);
         for (const arcName of arcs) {
             const arcPath = join(args.contentPath, arcName);
-            let arc = await tracker.getArc(timeline, arcName);
+            let arc = await tracker.getArc(args.timeline, arcName);
             if (!arc) {
                 arc = await tracker.createArc({
-                    timelineName: timeline,
+                    timelineName: args.timeline,
                     name: arcName,
                     number: 1,
                     description: `Arc ${arcName}`,
@@ -41,11 +40,11 @@ export async function timelineSync(args, tracker) {
             }));
             for (const ep of episodes) {
                 const episodePath = join(arcPath, ep.name);
-                let episode = await tracker.getEpisode(timeline, arcName, ep.number);
+                let episode = await tracker.getEpisode(args.timeline, arcName, ep.number);
                 if (!episode) {
                     try {
                         episode = await tracker.createEpisode({
-                            timelineName: timeline,
+                            timelineName: args.timeline,
                             arcName: arcName,
                             number: ep.number,
                             slug: ep.name,
@@ -57,7 +56,7 @@ export async function timelineSync(args, tracker) {
                     catch (error) {
                         console.error(`Error creating episode ${arcName}/ep${ep.number}:`, error instanceof Error ? error.message : error);
                         errors++;
-                        continue; // Skip chapters if episode creation failed
+                        continue;
                     }
                 }
                 const chapters = readdirSync(episodePath)
@@ -80,15 +79,13 @@ export async function timelineSync(args, tracker) {
                     }
                 })
                     .filter((ch) => ch !== null);
-                // Collect unique part numbers
                 const partNumbers = new Set(chapters.map((ch) => ch?.metadata.part || 1));
-                // Create parts if they don't exist
                 for (const partNum of partNumbers) {
                     try {
-                        const existingPart = await tracker.getPart(timeline, arcName, ep.number, partNum);
+                        const existingPart = await tracker.getPart(args.timeline, arcName, ep.number, partNum);
                         if (!existingPart) {
                             await tracker.createPart({
-                                timelineName: timeline,
+                                timelineName: args.timeline,
                                 arcName: arcName,
                                 episodeNumber: ep.number,
                                 number: partNum,
@@ -111,17 +108,22 @@ export async function timelineSync(args, tracker) {
                     if (!chNumber)
                         continue;
                     try {
-                        const existing = await tracker.getChapter(timeline, arcName, ep.number, chNumber);
+                        const existing = await tracker.getChapter(args.timeline, arcName, ep.number, chNumber);
                         const data = {
-                            timelineName: timeline,
+                            timelineName: args.timeline,
                             arcName: arcName,
                             episodeNumber: ep.number,
                             partNumber: chapterData.metadata.part || 1,
                             number: chNumber,
+                            timeline: args.timeline,
+                            arc: arcName,
+                            episode: ep.number,
+                            part: chapterData.metadata.part || 1,
+                            chapter: chNumber,
                             pov: chapterData.metadata.pov || 'Unknown',
                             title: chapterData.metadata.title || 'Untitled',
-                            date: new Date(chapterData.metadata.date || Date.now()),
-                            excerpt: chapterData.metadata.excerpt || '',
+                            date: new Date(chapterData.metadata.date || Date.now()).toISOString(),
+                            summary: chapterData.metadata.summary || '',
                             location: chapterData.metadata.location || '',
                             outfit: chapterData.metadata.outfit || '',
                             kink: chapterData.metadata.kink || '',
@@ -133,7 +135,7 @@ export async function timelineSync(args, tracker) {
                             readingTimeMinutes: Math.ceil(chapterData.stats.words / 200),
                         };
                         if (existing) {
-                            await tracker.updateChapter(timeline, arcName, ep.number, chNumber, data);
+                            await tracker.updateChapter(args.timeline, arcName, ep.number, chNumber, data);
                             updated++;
                         }
                         else {
@@ -148,11 +150,11 @@ export async function timelineSync(args, tracker) {
             }
         }
         try {
-            const dbArcs = await tracker.getArcs(timeline);
+            const dbArcs = await tracker.getArcs(args.timeline);
             for (const arc of dbArcs) {
-                const dbEpisodes = await tracker.getEpisodes(timeline, arc.name);
+                const dbEpisodes = await tracker.getEpisodes(args.timeline, arc.name);
                 for (const episode of dbEpisodes) {
-                    const allChapters = await tracker.getChapters(timeline, arc.name, episode.number);
+                    const allChapters = await tracker.getChapters(args.timeline, arc.name, episode.number);
                     for (const dbChapter of allChapters) {
                         let fileExists = false;
                         try {
@@ -195,7 +197,7 @@ export async function timelineSync(args, tracker) {
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        timeline,
+                        timeline: args.timeline,
                         contentPath: args.contentPath,
                         summary: {
                             added,

package/lib/utils.d.ts

@@ -1 +1 @@
-export declare function getTimeline(): string;
+export {};

package/lib/utils.js

@@ -1,7 +1,2 @@
-export function getTimeline() {
-    const timeline = process.env.ECHOES_TIMELINE;
-    if (!timeline) {
-        throw new Error('ECHOES_TIMELINE environment variable is not set');
-    }
-    return timeline;
-}
+export {};
+// Removed getTimeline() - timeline is now a required parameter for all tools

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echoes-io/mcp-server",
   "type": "module",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "Model Context Protocol server for AI integration with Echoes storytelling platform",
   "scripts": {
     "dev": "tsx cli/index.ts",
@@ -13,6 +13,7 @@
     "lint:publish": "publint --strict",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
+    "check": "npm run clean && npm run test:coverage && npm run build && npm run lint && npm run clean",
     "prepare": "[ \"$CI\" = \"true\" ] || [ \"$GITHUB_ACTIONS\" = \"true\" ] && echo 'Skipping husky' && exit 0 || husky",
     "clean": "rimraf --glob ./{cli,lib,test}/**/*.{d.ts,js} ./vitest*.{d.ts,js}",
     "prebuild": "npm run clean",
@@ -62,7 +63,7 @@
     ]
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.7",
+    "@biomejs/biome": "^2.3.2",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@tsconfig/node22": "^22.0.2",
@@ -81,11 +82,11 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@echoes-io/books-generator": "^1.0.0",
-    "@echoes-io/models": "^1.0.1",
+    "@echoes-io/books-generator": "^1.0.1",
+    "@echoes-io/models": "^1.0.2",
     "@echoes-io/rag": "^1.1.2",
-    "@echoes-io/tracker": "^1.0.0",
-    "@echoes-io/utils": "^1.1.1",
+    "@echoes-io/tracker": "^1.0.1",
+    "@echoes-io/utils": "^1.2.0",
     "@modelcontextprotocol/sdk": "^1.0.0"
   }
 }