@echoes-io/mcp-server 1.3.0 → 1.3.2

package/README.md

@@ -97,8 +97,9 @@ All tools operate on the timeline specified by the `ECHOES_TIMELINE` environment
 
 ### RAG (Semantic Search)
 - **`rag-index`** - Index chapters into vector database for semantic search
-  - Input: optional: `arc`, `episode` (to index specific content)
+  - Input: `contentPath` (path to content directory, required for full content indexing), optional: `arc`, `episode` (to index specific content)
   - Output: Number of chapters indexed
+  - Note: Requires `contentPath` to read and index actual chapter content. Without it, only metadata is indexed.
   
 - **`rag-search`** - Semantic search across timeline content
   - Input: `query`, optional: `arc`, `pov`, `maxResults`

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

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

package/lib/tools/rag-index.js

@@ -1,6 +1,10 @@
+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({
+    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)'),
 });
@@ -30,11 +34,50 @@ export async function ragIndex(args, tracker, rag) {
             }
         }
         // Convert to embedding format and add to RAG
-        const embeddingChapters = chapters.map((ch) => ({
-            id: `${ch.timelineName}-${ch.arcName}-${ch.episodeNumber}-${ch.number}`,
-            metadata: ch,
-            content: '', // Content will be loaded by RAG system if needed
-        }));
+        const embeddingChapters = chapters
+            .map((ch) => {
+            // If contentPath is provided, read actual file content
+            if (args.contentPath) {
+                try {
+                    // Reconstruct file path from chapter metadata
+                    const episodeDir = `ep${String(ch.episodeNumber).padStart(2, '0')}`;
+                    const chapterFile = `ep${String(ch.episodeNumber).padStart(2, '0')}-ch${String(ch.number).padStart(3, '0')}-${ch.pov}`;
+                    // Try to find the file (we don't know the exact title part)
+                    const arcPath = join(args.contentPath, ch.arcName);
+                    const episodePath = readdirSync(arcPath, { withFileTypes: true })
+                        .filter((e) => e.isDirectory() && e.name.startsWith(episodeDir))
+                        .map((e) => join(arcPath, e.name))[0];
+                    if (!episodePath) {
+                        console.error(`Episode directory not found for ${ch.arcName}/ep${ch.episodeNumber}`);
+                        return null;
+                    }
+                    const chapterFiles = readdirSync(episodePath).filter((f) => f.startsWith(chapterFile) && f.endsWith('.md'));
+                    if (chapterFiles.length === 0) {
+                        console.error(`Chapter file not found for ${ch.arcName}/ep${ch.episodeNumber}/ch${ch.number}`);
+                        return null;
+                    }
+                    const filePath = join(episodePath, chapterFiles[0]);
+                    const fileContent = readFileSync(filePath, 'utf-8');
+                    const { content } = parseMarkdown(fileContent);
+                    return {
+                        id: `${ch.timelineName}-${ch.arcName}-${ch.episodeNumber}-${ch.number}`,
+                        metadata: ch,
+                        content,
+                    };
+                }
+                catch (error) {
+                    console.error(`Error reading chapter ${ch.arcName}/ep${ch.episodeNumber}/ch${ch.number}:`, error);
+                    return null;
+                }
+            }
+            // Fallback: no content (for tests or when contentPath not provided)
+            return {
+                id: `${ch.timelineName}-${ch.arcName}-${ch.episodeNumber}-${ch.number}`,
+                metadata: ch,
+                content: '',
+            };
+        })
+            .filter((ch) => ch !== null);
         await rag.addChapters(embeddingChapters);
         return {
             content: [

package/lib/tools/timeline-sync.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { getTextStats, parseMarkdown } from '@echoes-io/utils';
 import { z } from 'zod';
@@ -43,22 +43,29 @@ export async function timelineSync(args, tracker) {
                 const episodePath = join(arcPath, ep.name);
                 let episode = await tracker.getEpisode(timeline, arcName, ep.number);
                 if (!episode) {
-                    episode = await tracker.createEpisode({
-                        timelineName: timeline,
-                        arcName: arcName,
-                        number: ep.number,
-                        slug: ep.name,
-                        title: ep.name,
-                        description: `Episode ${ep.number}`,
-                    });
-                    added++;
+                    try {
+                        episode = await tracker.createEpisode({
+                            timelineName: timeline,
+                            arcName: arcName,
+                            number: ep.number,
+                            slug: ep.name,
+                            title: ep.name,
+                            description: `Episode ${ep.number}`,
+                        });
+                        added++;
+                    }
+                    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
+                    }
                 }
                 const chapters = readdirSync(episodePath)
                     .filter((file) => extname(file) === '.md')
                     .map((file) => {
                     try {
                         const filePath = join(episodePath, file);
-                        const content = require('node:fs').readFileSync(filePath, 'utf-8');
+                        const content = readFileSync(filePath, 'utf-8');
                         const { metadata, content: markdownContent } = parseMarkdown(content);
                         const stats = getTextStats(markdownContent);
                         return {
@@ -73,6 +80,30 @@ 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);
+                        if (!existingPart) {
+                            await tracker.createPart({
+                                timelineName: timeline,
+                                arcName: arcName,
+                                episodeNumber: ep.number,
+                                number: partNum,
+                                slug: `part-${partNum}`,
+                                title: `Part ${partNum}`,
+                                description: `Part ${partNum} of Episode ${ep.number}`,
+                            });
+                            added++;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Error creating part ${arcName}/ep${ep.number}/part${partNum}:`, error instanceof Error ? error.message : error);
+                        errors++;
+                    }
+                }
                 for (const chapterData of chapters) {
                     if (!chapterData)
                         continue;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echoes-io/mcp-server",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Model Context Protocol server for AI integration with Echoes storytelling platform",
   "scripts": {
     "dev": "tsx cli/index.ts",