@echoes-io/mcp-server 4.0.0 → 4.1.1

package/src/tools/words-count.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import { parseMarkdown } from '../utils/markdown.js';
+export const wordsCountSchema = z.object({
+    filePath: z.string().describe('Path to the markdown file'),
+    detailed: z.boolean().optional().describe('Include detailed statistics'),
+});
+export async function wordsCount(input) {
+    const { filePath, detailed = false } = wordsCountSchema.parse(input);
+    const content = readFileSync(filePath, 'utf-8');
+    const { content: text } = parseMarkdown(content);
+    // Basic stats
+    const words = text.split(/\s+/).filter((word) => word.length > 0).length;
+    const characters = text.length;
+    const charactersNoSpaces = text.replace(/\s/g, '').length;
+    const readingTimeMinutes = Math.ceil(words / 200); // 200 WPM average
+    const result = {
+        words,
+        characters,
+        charactersNoSpaces,
+        readingTimeMinutes,
+    };
+    if (detailed) {
+        result.sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0).length;
+        result.paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length;
+    }
+    return result;
+}

package/src/types/frontmatter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Frontmatter metadata from YAML headers
+ */
+export interface ChapterMetadata {
+    pov: string;
+    title: string;
+    date: string;
+    timeline: string;
+    arc: string;
+    episode: number;
+    part: number;
+    chapter: number;
+    summary: string;
+    location: string;
+    outfit?: string;
+    kink?: string;
+}
+/**
+ * Text statistics calculated from content
+ */
+export interface TextStats {
+    words: number;
+    characters: number;
+    charactersNoSpaces: number;
+    paragraphs: number;
+    sentences: number;
+    readingTimeMinutes: number;
+}
+/**
+ * Result of parsing a markdown file
+ */
+export interface ParsedMarkdown {
+    metadata: ChapterMetadata;
+    content: string;
+}

package/src/types/frontmatter.js

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

package/src/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './markdown.js';

package/src/utils/index.js

@@ -0,0 +1 @@
+export * from './markdown.js';

package/src/utils/markdown.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedMarkdown, TextStats } from '../types/frontmatter.js';
+/**
+ * Markdown parsing utilities
+ */
+export declare function parseMarkdown(markdown: string): ParsedMarkdown;
+export declare function getTextStats(markdown: string): TextStats;

package/src/utils/markdown.js

@@ -0,0 +1,36 @@
+import matter from 'gray-matter';
+import removeMd from 'remove-markdown';
+/**
+ * Markdown parsing utilities
+ */
+export function parseMarkdown(markdown) {
+    const { data, content } = matter(markdown);
+    // Convert Date objects to strings
+    if (data.date instanceof Date) {
+        data.date = data.date.toISOString().split('T')[0];
+    }
+    return {
+        metadata: data,
+        content: content.trim(),
+    };
+}
+export function getTextStats(markdown) {
+    const { content } = parseMarkdown(markdown);
+    // Strip markdown
+    const withoutHeaders = content.replace(/^#{1,6}\s+.*$/gm, '');
+    const plainText = removeMd(withoutHeaders);
+    const words = plainText.trim().match(/\b\w+\b/g)?.length || 0;
+    const characters = plainText.length;
+    const charactersNoSpaces = plainText.replace(/\s/g, '').length;
+    const paragraphs = plainText.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length;
+    const sentences = plainText.split(/[.!?]+/).filter((s) => s.trim().length > 0).length;
+    const readingTimeMinutes = Math.ceil(words / 200);
+    return {
+        words,
+        characters,
+        charactersNoSpaces,
+        paragraphs,
+        sentences,
+        readingTimeMinutes,
+    };
+}

package/src/utils/timeline-detection.d.ts

@@ -0,0 +1,13 @@
+export interface TimelineContext {
+    timeline: string;
+    contentPath: string;
+    mode: 'single-timeline' | 'multi-timeline' | 'test';
+}
+/**
+ * Auto-detect timeline and content path based on current working directory
+ */
+export declare function detectTimelineContext(cwd?: string): TimelineContext;
+/**
+ * Get timeline context with optional override
+ */
+export declare function getTimelineContext(timelineOverride?: string, contentPathOverride?: string): TimelineContext;

package/src/utils/timeline-detection.js

@@ -0,0 +1,76 @@
+import { basename, dirname, resolve } from 'node:path';
+/**
+ * Auto-detect timeline and content path based on current working directory
+ */
+export function detectTimelineContext(cwd = process.cwd()) {
+    const currentDir = basename(cwd);
+    // Single Timeline Mode: timeline-* directory
+    if (currentDir.startsWith('timeline-')) {
+        const timeline = currentDir.replace('timeline-', '');
+        const contentPath = resolve(cwd, 'content');
+        console.error(`[DEBUG] Mode: single-timeline "${timeline}"`);
+        return {
+            timeline,
+            contentPath,
+            mode: 'single-timeline',
+        };
+    }
+    // Multi-Timeline Mode: .github directory
+    if (currentDir === '.github') {
+        const parentDir = dirname(cwd);
+        console.error(`[DEBUG] Mode: multi-timeline (scanning ${parentDir})`);
+        // For multi-timeline, we need the timeline parameter
+        throw new Error('Multi-timeline mode requires explicit timeline parameter');
+    }
+    // Test Mode: mcp-server directory
+    if (currentDir === 'mcp-server') {
+        console.error('[DEBUG] Mode: test from mcp-server (in-memory)');
+        return {
+            timeline: 'test',
+            contentPath: resolve(cwd, 'test/fixtures'),
+            mode: 'test',
+        };
+    }
+    // Fallback: try to find timeline-* in parent directories
+    let searchDir = cwd;
+    for (let i = 0; i < 5; i++) {
+        const dirName = basename(searchDir);
+        if (dirName.startsWith('timeline-')) {
+            const timeline = dirName.replace('timeline-', '');
+            const contentPath = resolve(searchDir, 'content');
+            console.error(`[DEBUG] Mode: single-timeline "${timeline}" (found in parent)`);
+            return {
+                timeline,
+                contentPath,
+                mode: 'single-timeline',
+            };
+        }
+        const parent = dirname(searchDir);
+        if (parent === searchDir)
+            break; // reached root
+        searchDir = parent;
+    }
+    throw new Error('Could not detect timeline context. Run from:\n' +
+        '  - timeline-* directory (single timeline mode)\n' +
+        '  - .github directory (multi-timeline mode)\n' +
+        '  - mcp-server directory (test mode)\n' +
+        'Or provide explicit timeline parameter');
+}
+/**
+ * Get timeline context with optional override
+ */
+export function getTimelineContext(timelineOverride, contentPathOverride) {
+    if (timelineOverride && contentPathOverride) {
+        return {
+            timeline: timelineOverride,
+            contentPath: contentPathOverride,
+            mode: 'single-timeline',
+        };
+    }
+    const detected = detectTimelineContext();
+    return {
+        timeline: timelineOverride || detected.timeline,
+        contentPath: contentPathOverride || detected.contentPath,
+        mode: detected.mode,
+    };
+}