@echoes-io/mcp-server 3.0.0 → 4.0.0

package/lib/tools/stats.js

@@ -1,132 +0,0 @@
-import { z } from 'zod';
-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 {
-        let chapters = [];
-        // Get chapters based on filters
-        if (args.arc && args.episode) {
-            chapters = await tracker.getChapters(args.timeline, args.arc, args.episode);
-        }
-        else if (args.arc) {
-            const episodes = await tracker.getEpisodes(args.timeline, args.arc);
-            for (const ep of episodes) {
-                const epChapters = await tracker.getChapters(args.timeline, args.arc, ep.number);
-                chapters.push(...epChapters);
-            }
-        }
-        else {
-            const arcs = await tracker.getArcs(args.timeline);
-            for (const arc of arcs) {
-                const episodes = await tracker.getEpisodes(args.timeline, arc.name);
-                for (const ep of episodes) {
-                    const epChapters = await tracker.getChapters(args.timeline, arc.name, ep.number);
-                    chapters.push(...epChapters);
-                }
-            }
-        }
-        // Filter by POV if specified
-        if (args.pov) {
-            chapters = chapters.filter((ch) => ch.pov === args.pov);
-        }
-        // Calculate statistics
-        const totalWords = chapters.reduce((sum, ch) => sum + ch.words, 0);
-        const totalChapters = chapters.length;
-        // POV distribution
-        const povStats = {};
-        for (const ch of chapters) {
-            if (!povStats[ch.pov]) {
-                povStats[ch.pov] = { chapters: 0, words: 0 };
-            }
-            povStats[ch.pov].chapters++;
-            povStats[ch.pov].words += ch.words;
-        }
-        // Arc breakdown (if not filtered by arc)
-        const arcStats = {};
-        if (!args.arc) {
-            for (const ch of chapters) {
-                if (!arcStats[ch.arcName]) {
-                    arcStats[ch.arcName] = { chapters: 0, words: 0, episodes: new Set() };
-                }
-                arcStats[ch.arcName].chapters++;
-                arcStats[ch.arcName].words += ch.words;
-                arcStats[ch.arcName].episodes.add(ch.episodeNumber);
-            }
-        }
-        // Episode breakdown (if filtered by arc but not episode)
-        const episodeStats = {};
-        if (args.arc && !args.episode) {
-            for (const ch of chapters) {
-                if (!episodeStats[ch.episodeNumber]) {
-                    episodeStats[ch.episodeNumber] = { chapters: 0, words: 0 };
-                }
-                episodeStats[ch.episodeNumber].chapters++;
-                episodeStats[ch.episodeNumber].words += ch.words;
-            }
-        }
-        const result = {
-            timeline: args.timeline,
-            filters: {
-                arc: args.arc || null,
-                episode: args.episode || null,
-                pov: args.pov || null,
-            },
-            summary: {
-                totalChapters,
-                totalWords,
-                averageChapterLength: totalChapters > 0 ? Math.round(totalWords / totalChapters) : 0,
-            },
-            povDistribution: Object.entries(povStats).map(([pov, stats]) => ({
-                pov,
-                chapters: stats.chapters,
-                words: stats.words,
-                percentage: totalWords > 0 ? Math.round((stats.words / totalWords) * 100) : 0,
-            })),
-        };
-        if (!args.arc && Object.keys(arcStats).length > 0) {
-            result.arcBreakdown = Object.entries(arcStats).map(([arc, stats]) => ({
-                arc,
-                chapters: stats.chapters,
-                words: stats.words,
-                episodes: stats.episodes.size,
-            }));
-        }
-        if (args.arc && !args.episode && Object.keys(episodeStats).length > 0) {
-            result.episodeBreakdown = Object.entries(episodeStats).map(([episode, stats]) => ({
-                episode: Number(episode),
-                chapters: stats.chapters,
-                words: stats.words,
-            }));
-        }
-        if (totalChapters > 0) {
-            const sortedByWords = [...chapters].sort((a, b) => b.words - a.words);
-            result.extremes = {
-                longest: {
-                    title: sortedByWords[0].title,
-                    pov: sortedByWords[0].pov,
-                    words: sortedByWords[0].words,
-                },
-                shortest: {
-                    title: sortedByWords[sortedByWords.length - 1].title,
-                    pov: sortedByWords[sortedByWords.length - 1].pov,
-                    words: sortedByWords[sortedByWords.length - 1].words,
-                },
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to get stats: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

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

@@ -1,15 +0,0 @@
-import type { Tracker } from '@echoes-io/tracker';
-import { z } from 'zod';
-export declare const timelineSyncSchema: z.ZodObject<{
-    timeline: z.ZodString;
-}, z.core.$strip>;
-type TimelineSyncArgs = z.infer<typeof timelineSyncSchema> & {
-    contentPath: string;
-};
-export declare function timelineSync(args: TimelineSyncArgs, tracker: Tracker): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export {};

package/lib/tools/timeline-sync.js

@@ -1,217 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { extname, join } from 'node:path';
-import { getTextStats, parseMarkdown } from '@echoes-io/utils';
-import { z } from 'zod';
-export const timelineSyncSchema = z.object({
-    timeline: z.string().describe('Timeline name'),
-});
-export async function timelineSync(args, tracker) {
-    try {
-        let added = 0, updated = 0, deleted = 0, errors = 0;
-        let timelineRecord = await tracker.getTimeline(args.timeline);
-        if (!timelineRecord) {
-            timelineRecord = await tracker.createTimeline({
-                name: args.timeline,
-                description: `Timeline ${args.timeline}`,
-            });
-            added++;
-        }
-        const arcs = readdirSync(args.contentPath, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name);
-        for (const arcName of arcs) {
-            const arcPath = join(args.contentPath, arcName);
-            let arc = await tracker.getArc(args.timeline, arcName);
-            if (!arc) {
-                arc = await tracker.createArc({
-                    timelineName: args.timeline,
-                    name: arcName,
-                    number: 1,
-                    description: `Arc ${arcName}`,
-                });
-                added++;
-            }
-            const episodes = readdirSync(arcPath, { withFileTypes: true })
-                .filter((entry) => entry.isDirectory() && entry.name.startsWith('ep'))
-                .map((entry) => ({
-                name: entry.name,
-                number: Number.parseInt(entry.name.match(/ep(\d+)/)?.[1] || '0', 10),
-            }));
-            for (const ep of episodes) {
-                const episodePath = join(arcPath, ep.name);
-                let episode = await tracker.getEpisode(args.timeline, arcName, ep.number);
-                if (!episode) {
-                    try {
-                        episode = await tracker.createEpisode({
-                            timelineName: args.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;
-                    }
-                }
-                const chapters = readdirSync(episodePath)
-                    .filter((file) => extname(file) === '.md')
-                    .map((file) => {
-                    try {
-                        const filePath = join(episodePath, file);
-                        const content = readFileSync(filePath, 'utf-8');
-                        const { metadata, content: markdownContent } = parseMarkdown(content);
-                        const stats = getTextStats(markdownContent);
-                        return {
-                            file: filePath,
-                            metadata,
-                            stats,
-                        };
-                    }
-                    catch (_error) {
-                        console.error(`Error parsing chapter file ${file}:`, _error instanceof Error ? _error.message : _error);
-                        errors++;
-                        return null;
-                    }
-                })
-                    .filter((ch) => ch !== null);
-                const partNumbers = new Set(chapters.map((ch) => ch?.metadata.part || 1));
-                for (const partNum of partNumbers) {
-                    try {
-                        const existingPart = await tracker.getPart(args.timeline, arcName, ep.number, partNum);
-                        if (!existingPart) {
-                            await tracker.createPart({
-                                timelineName: args.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;
-                    const chNumber = chapterData.metadata.chapter;
-                    if (!chNumber)
-                        continue;
-                    try {
-                        const existing = await tracker.getChapter(args.timeline, arcName, ep.number, chNumber);
-                        const data = {
-                            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: chapterData.metadata.date || '',
-                            summary: chapterData.metadata.summary || '',
-                            location: chapterData.metadata.location || '',
-                            outfit: chapterData.metadata.outfit || '',
-                            kink: chapterData.metadata.kink || '',
-                            words: chapterData.stats.words,
-                            characters: chapterData.stats.characters,
-                            charactersNoSpaces: chapterData.stats.charactersNoSpaces,
-                            paragraphs: chapterData.stats.paragraphs,
-                            sentences: chapterData.stats.sentences,
-                            readingTimeMinutes: Math.ceil(chapterData.stats.words / 200),
-                        };
-                        if (existing) {
-                            await tracker.updateChapter(args.timeline, arcName, ep.number, chNumber, data);
-                            updated++;
-                        }
-                        else {
-                            await tracker.createChapter(data);
-                            added++;
-                        }
-                    }
-                    catch (_error) {
-                        console.error(`Error creating/updating chapter ${arcName}/ep${ep.number}/ch${chNumber}:`, _error instanceof Error ? _error.message : _error);
-                        errors++;
-                    }
-                }
-            }
-        }
-        try {
-            const dbArcs = await tracker.getArcs(args.timeline);
-            for (const arc of dbArcs) {
-                const dbEpisodes = await tracker.getEpisodes(args.timeline, arc.name);
-                for (const episode of dbEpisodes) {
-                    const allChapters = await tracker.getChapters(args.timeline, arc.name, episode.number);
-                    for (const dbChapter of allChapters) {
-                        let fileExists = false;
-                        try {
-                            const arcPath = join(args.contentPath, dbChapter.arcName);
-                            if (existsSync(arcPath)) {
-                                const episodeDirs = readdirSync(arcPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() &&
-                                    entry.name.startsWith(`ep${dbChapter.episodeNumber.toString().padStart(2, '0')}-`));
-                                for (const episodeDir of episodeDirs) {
-                                    const episodePath = join(arcPath, episodeDir.name);
-                                    const chapterFiles = readdirSync(episodePath).filter((file) => file.includes(`ch${dbChapter.number.toString().padStart(3, '0')}`) &&
-                                        file.endsWith('.md'));
-                                    if (chapterFiles.length > 0) {
-                                        fileExists = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        catch (_error) {
-                            fileExists = false;
-                        }
-                        if (!fileExists) {
-                            try {
-                                await tracker.deleteChapter(dbChapter.timelineName, dbChapter.arcName, dbChapter.episodeNumber, dbChapter.number);
-                                deleted++;
-                            }
-                            catch (_error) {
-                                errors++;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (_error) {
-            errors++;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        timeline: args.timeline,
-                        contentPath: args.contentPath,
-                        summary: {
-                            added,
-                            updated,
-                            deleted,
-                            errors,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to sync timeline: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

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

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

package/lib/tools/words-count.js

@@ -1,30 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { getTextStats } from '@echoes-io/utils';
-import { z } from 'zod';
-export const wordsCountSchema = z.object({
-    file: z.string().describe('Path to markdown file'),
-});
-export async function wordsCount(args) {
-    try {
-        const content = readFileSync(args.file, 'utf-8');
-        const stats = getTextStats(content);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        file: args.file,
-                        words: stats.words,
-                        characters: stats.characters,
-                        charactersNoSpaces: stats.charactersNoSpaces,
-                        paragraphs: stats.paragraphs,
-                        sentences: stats.sentences,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to count words: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}

package/lib/utils.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/utils.js

@@ -1,2 +0,0 @@
-export {};
-// Removed getTimeline() - timeline is now a required parameter for all tools