liferewind 0.1.0

package/dist/sources/chatbot/readers/base.js

@@ -0,0 +1,109 @@
+import { copyFileSync, unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import Database from 'better-sqlite3';
+export class ChatbotReader {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    read() {
+        const dbPath = this.getDbPath();
+        if (!dbPath) {
+            this.context.logger.debug(`No ${this.clientType} database found`);
+            return [];
+        }
+        return this.readFromDb(dbPath);
+    }
+    hasValidDatabase() {
+        const dbPath = this.getDbPath();
+        return dbPath !== null && existsSync(dbPath);
+    }
+    readFromDb(dbPath) {
+        const tempPath = join(tmpdir(), `chatbot-history-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+        let db = null;
+        try {
+            // Copy database to avoid locking issues
+            copyFileSync(dbPath, tempPath);
+            db = new Database(tempPath, { readonly: true });
+            const sinceTimestamp = Date.now() - this.context.sinceDays * 24 * 60 * 60 * 1000;
+            // Get chat sessions
+            const chatStmt = db.prepare(this.getChatQuery());
+            const chatRows = chatStmt.all(sinceTimestamp);
+            const results = [];
+            for (const chatRow of chatRows) {
+                const session = this.parseChatRow(chatRow);
+                if (!session)
+                    continue;
+                // Check model exclusion
+                if (session.model && this.isModelExcluded(session.model)) {
+                    continue;
+                }
+                // Get messages for this chat
+                const messages = this.getMessagesForChat(db, session.id);
+                // Update message count
+                session.messageCount = messages.length;
+                results.push({
+                    client: this.clientType,
+                    session,
+                    messages,
+                });
+            }
+            this.context.logger.debug(`Read ${results.length} chats from ${this.clientType}`);
+            return results;
+        }
+        finally {
+            // Close database connection
+            if (db) {
+                try {
+                    db.close();
+                }
+                catch (error) {
+                    this.context.logger.debug('Failed to close database connection', error);
+                }
+            }
+            // Clean up temp file
+            if (existsSync(tempPath)) {
+                try {
+                    unlinkSync(tempPath);
+                }
+                catch (error) {
+                    this.context.logger.debug(`Failed to clean up temp file: ${tempPath}`, error);
+                }
+            }
+        }
+    }
+    getMessagesForChat(db, chatId) {
+        const stmt = db.prepare(this.getMessageQuery());
+        const rows = stmt.all(chatId);
+        let messages = rows
+            .map((row) => this.parseMessageRow(row))
+            .filter((msg) => msg !== null);
+        // Filter by model exclusion
+        messages = messages.filter((msg) => {
+            if (msg.model && this.isModelExcluded(msg.model)) {
+                return false;
+            }
+            return true;
+        });
+        // Strip content if not included
+        if (!this.context.includeContent) {
+            messages = messages.map((msg) => ({
+                ...msg,
+                content: '',
+                reasoningContent: undefined,
+            }));
+        }
+        // Limit message count (keep most recent)
+        if (this.context.maxMessagesPerChat && messages.length > this.context.maxMessagesPerChat) {
+            messages = messages.slice(-this.context.maxMessagesPerChat);
+        }
+        return messages;
+    }
+    isModelExcluded(model) {
+        if (!this.context.excludeModels || this.context.excludeModels.length === 0) {
+            return false;
+        }
+        return this.context.excludeModels.some((excluded) => model.toLowerCase().includes(excluded.toLowerCase()));
+    }
+}

package/dist/sources/chatbot/readers/chatwise.d.ts

@@ -0,0 +1,14 @@
+import { ChatbotReader } from './base.js';
+import type { ChatbotType, ChatSession, ChatMessage } from '../types.js';
+export declare class ChatWiseReader extends ChatbotReader {
+    readonly clientType: ChatbotType;
+    getDbPath(): string | null;
+    getChatQuery(): string;
+    getMessageQuery(): string;
+    parseChatRow(row: unknown): ChatSession | null;
+    parseMessageRow(row: unknown): ChatMessage | null;
+    private isValidChatRow;
+    private isValidMessageRow;
+    private normalizeRole;
+}
+//# sourceMappingURL=chatwise.d.ts.map

package/dist/sources/chatbot/readers/chatwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatwise.d.ts","sourceRoot":"","sources":["../../../../src/sources/chatbot/readers/chatwise.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAwBzE,qBAAa,cAAe,SAAQ,aAAa;IAC/C,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAc;IAE9C,SAAS,IAAI,MAAM,GAAG,IAAI;IAO1B,YAAY,IAAI,MAAM;IAgBtB,eAAe,IAAI,MAAM;IAiBzB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI;IAgB9C,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI;IAkCjD,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,aAAa;CAOtB"}

package/dist/sources/chatbot/readers/chatwise.js

@@ -0,0 +1,117 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { ChatbotReader } from './base.js';
+const CHATWISE_DB_PATH = join(homedir(), 'Library', 'Application Support', 'app.chatwise', 'app.db');
+export class ChatWiseReader extends ChatbotReader {
+    clientType = 'chatwise';
+    getDbPath() {
+        if (existsSync(CHATWISE_DB_PATH)) {
+            return CHATWISE_DB_PATH;
+        }
+        return null;
+    }
+    getChatQuery() {
+        // lastReplyAt is stored as Unix milliseconds
+        return `
+      SELECT
+        id,
+        title,
+        model,
+        createdAt,
+        lastReplyAt,
+        assistantId
+      FROM chat
+      WHERE lastReplyAt > ?
+      ORDER BY lastReplyAt DESC
+    `;
+    }
+    getMessageQuery() {
+        return `
+      SELECT
+        id,
+        chatId,
+        role,
+        content,
+        model,
+        createdAt,
+        files,
+        reasoningContent
+      FROM message
+      WHERE chatId = ?
+      ORDER BY createdAt ASC
+    `;
+    }
+    parseChatRow(row) {
+        if (!this.isValidChatRow(row)) {
+            return null;
+        }
+        return {
+            id: row.id,
+            title: row.title ?? 'Untitled',
+            model: row.model ?? undefined,
+            createdAt: new Date(row.createdAt).toISOString(),
+            lastReplyAt: new Date(row.lastReplyAt).toISOString(),
+            assistantId: row.assistantId ?? undefined,
+            messageCount: 0, // Will be updated after fetching messages
+        };
+    }
+    parseMessageRow(row) {
+        if (!this.isValidMessageRow(row)) {
+            return null;
+        }
+        let files;
+        if (row.files) {
+            try {
+                const parsed = JSON.parse(row.files);
+                if (Array.isArray(parsed) && parsed.every((f) => typeof f === 'string')) {
+                    files = parsed;
+                }
+            }
+            catch {
+                // Invalid JSON, ignore
+            }
+        }
+        const role = this.normalizeRole(row.role);
+        if (!role) {
+            return null;
+        }
+        return {
+            id: row.id,
+            chatId: row.chatId,
+            role,
+            content: row.content ?? '',
+            model: row.model ?? undefined,
+            createdAt: new Date(row.createdAt).toISOString(),
+            files,
+            reasoningContent: row.reasoningContent ?? undefined,
+        };
+    }
+    isValidChatRow(row) {
+        if (typeof row !== 'object' || row === null)
+            return false;
+        const r = row;
+        return (typeof r['id'] === 'string' &&
+            typeof r['createdAt'] === 'number' &&
+            typeof r['lastReplyAt'] === 'number');
+    }
+    isValidMessageRow(row) {
+        if (typeof row !== 'object' || row === null)
+            return false;
+        const r = row;
+        return (typeof r['id'] === 'string' &&
+            typeof r['chatId'] === 'string' &&
+            typeof r['role'] === 'string' &&
+            typeof r['createdAt'] === 'number');
+    }
+    normalizeRole(role) {
+        const normalized = role.toLowerCase();
+        if (normalized === 'user')
+            return 'user';
+        if (normalized === 'assistant')
+            return 'assistant';
+        if (normalized === 'system')
+            return 'system';
+        return null;
+    }
+}

package/dist/sources/chatbot/types.d.ts

@@ -0,0 +1,33 @@
+export type ChatbotType = 'chatwise';
+export interface ChatMessage {
+    id: string;
+    chatId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    model?: string;
+    createdAt: string;
+    files?: string[];
+    reasoningContent?: string;
+}
+export interface ChatSession {
+    id: string;
+    title: string;
+    model?: string;
+    createdAt: string;
+    lastReplyAt: string;
+    assistantId?: string;
+    messageCount: number;
+}
+export interface ChatHistoryItem {
+    client: ChatbotType;
+    session: ChatSession;
+    messages: ChatMessage[];
+}
+export interface ChatbotSourceOptions {
+    clients: ChatbotType[];
+    sinceDays: number;
+    includeContent: boolean;
+    maxMessagesPerChat?: number;
+    excludeModels?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/sources/chatbot/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sources/chatbot/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC;AAErC,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B"}

package/dist/sources/chatbot/types.js

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

package/dist/sources/filesystem/index.d.ts

@@ -0,0 +1,10 @@
+import { DataSource } from '../base.js';
+import type { CollectionResult } from '../../core/types.js';
+import type { FilesystemSourceOptions } from './types.js';
+export declare class FilesystemSource extends DataSource<FilesystemSourceOptions> {
+    readonly type: "filesystem";
+    readonly name = "Filesystem Changes";
+    validate(): Promise<boolean>;
+    collect(): Promise<CollectionResult>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/sources/filesystem/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sources/filesystem/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAI1D,qBAAa,gBAAiB,SAAQ,UAAU,CAAC,uBAAuB,CAAC;IACvE,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IACtC,QAAQ,CAAC,IAAI,wBAAwB;IAE/B,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAqC5B,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAsB3C"}

package/dist/sources/filesystem/index.js

@@ -0,0 +1,58 @@
+import { existsSync, statSync } from 'node:fs';
+import { DataSource } from '../base.js';
+import { FilesystemScanner } from './scanner.js';
+import { expandPath } from '../../utils/path.js';
+export class FilesystemSource extends DataSource {
+    type = 'filesystem';
+    name = 'Filesystem Changes';
+    async validate() {
+        if (!this.options.watchPaths || this.options.watchPaths.length === 0) {
+            this.context.logger.error('No watch paths configured for filesystem source');
+            return false;
+        }
+        const validPaths = [];
+        for (const watchPath of this.options.watchPaths) {
+            const expanded = expandPath(watchPath);
+            if (!existsSync(expanded)) {
+                this.context.logger.warn(`Watch path does not exist: ${watchPath}`);
+                continue;
+            }
+            try {
+                const stat = statSync(expanded);
+                if (!stat.isDirectory()) {
+                    this.context.logger.warn(`Watch path is not a directory: ${watchPath}`);
+                    continue;
+                }
+                validPaths.push(expanded);
+            }
+            catch (error) {
+                this.context.logger.warn(`Cannot access watch path: ${watchPath}`, error);
+            }
+        }
+        if (validPaths.length === 0) {
+            this.context.logger.error('No valid watch paths found');
+            return false;
+        }
+        this.context.logger.info(`Validated ${validPaths.length} watch paths for filesystem source`);
+        return true;
+    }
+    async collect() {
+        const scanner = new FilesystemScanner({
+            logger: this.context.logger,
+            options: this.options,
+        });
+        const items = scanner.scan();
+        this.context.logger.info(`Found ${items.length} modified files`);
+        return {
+            sourceType: this.type,
+            success: true,
+            itemsCollected: items.length,
+            items: items.map((item) => ({
+                sourceType: this.type,
+                timestamp: new Date(item.modifiedAt),
+                data: item,
+            })),
+            collectedAt: new Date(),
+        };
+    }
+}

package/dist/sources/filesystem/scanner.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '../../utils/logger.js';
+import type { FileChangeItem, FilesystemSourceOptions } from './types.js';
+export interface ScannerContext {
+    logger: Logger;
+    options: FilesystemSourceOptions;
+}
+export declare class FilesystemScanner {
+    private context;
+    private sinceTimestamp;
+    constructor(context: ScannerContext);
+    /** Check if file matches exclude patterns */
+    private isExcluded;
+    /** Check if file matches allowed file types */
+    private matchesFileTypes;
+    /** Get MIME type based on extension */
+    private getMimeType;
+    /** Get content preview for text files */
+    private getContentPreview;
+    /** Scan a single directory recursively */
+    private scanDirectory;
+    /** Scan all configured watch paths */
+    scan(): FileChangeItem[];
+}
+//# sourceMappingURL=scanner.d.ts.map

package/dist/sources/filesystem/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../../../src/sources/filesystem/scanner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AA8I1E,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,uBAAuB,CAAC;CAClC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,cAAc,CAAS;gBAEnB,OAAO,EAAE,cAAc;IAMnC,6CAA6C;IAC7C,OAAO,CAAC,UAAU;IAMlB,+CAA+C;IAC/C,OAAO,CAAC,gBAAgB;IAQxB,uCAAuC;IACvC,OAAO,CAAC,WAAW;IAInB,yCAAyC;IACzC,OAAO,CAAC,iBAAiB;IAezB,0CAA0C;IAC1C,OAAO,CAAC,aAAa;IAuErB,sCAAsC;IACtC,IAAI,IAAI,cAAc,EAAE;CAiCzB"}

package/dist/sources/filesystem/scanner.js

@@ -0,0 +1,264 @@
+import { readdirSync, statSync, readFileSync } from 'node:fs';
+import { resolve, extname, basename, dirname } from 'node:path';
+import { minimatch } from 'minimatch';
+import { expandPath, isGitRepository } from '../../utils/path.js';
+/** Text file extensions that support content preview */
+const TEXT_EXTENSIONS = new Set([
+    '.txt',
+    '.md',
+    '.markdown',
+    '.json',
+    '.yaml',
+    '.yml',
+    '.xml',
+    '.csv',
+    '.tsv',
+    '.log',
+    '.rtf',
+    '.sql',
+    '.rmd',
+    '.qmd',
+]);
+/** Maximum characters to include in content preview */
+const CONTENT_PREVIEW_LENGTH = 500;
+/** MIME type mapping for common document formats */
+const MIME_MAP = {
+    // Text & Markdown
+    '.md': 'text/markdown',
+    '.markdown': 'text/markdown',
+    '.txt': 'text/plain',
+    '.rtf': 'text/rtf',
+    '.log': 'text/plain',
+    // Data formats
+    '.json': 'application/json',
+    '.yaml': 'application/x-yaml',
+    '.yml': 'application/x-yaml',
+    '.xml': 'application/xml',
+    '.csv': 'text/csv',
+    '.tsv': 'text/tab-separated-values',
+    // Documents
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.pages': 'application/vnd.apple.pages',
+    '.numbers': 'application/vnd.apple.numbers',
+    '.key': 'application/vnd.apple.keynote',
+    // Images
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.bmp': 'image/bmp',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff',
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.avif': 'image/avif',
+    '.psd': 'image/vnd.adobe.photoshop',
+    '.ai': 'application/postscript',
+    '.eps': 'application/postscript',
+    '.sketch': 'application/x-sketch',
+    '.fig': 'application/x-figma',
+    // Archives
+    '.zip': 'application/zip',
+    '.rar': 'application/vnd.rar',
+    '.7z': 'application/x-7z-compressed',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.bz2': 'application/x-bzip2',
+    '.xz': 'application/x-xz',
+    '.dmg': 'application/x-apple-diskimage',
+    // Applications & Installers
+    '.exe': 'application/x-msdownload',
+    '.msi': 'application/x-msi',
+    '.app': 'application/x-apple-application',
+    '.pkg': 'application/x-newton-compatible-pkg',
+    '.deb': 'application/x-deb',
+    '.rpm': 'application/x-rpm',
+    '.apk': 'application/vnd.android.package-archive',
+    '.ipa': 'application/x-ios-app',
+    // Data Science & Analytics
+    '.parquet': 'application/x-parquet',
+    '.feather': 'application/x-feather',
+    '.arrow': 'application/x-arrow',
+    '.pickle': 'application/x-pickle',
+    '.pkl': 'application/x-pickle',
+    '.h5': 'application/x-hdf5',
+    '.hdf5': 'application/x-hdf5',
+    '.npy': 'application/x-numpy',
+    '.npz': 'application/x-numpy',
+    '.sav': 'application/x-spss-sav',
+    '.dta': 'application/x-stata-dta',
+    '.rds': 'application/x-r-data',
+    '.rdata': 'application/x-r-data',
+    // Tableau
+    '.twb': 'application/x-tableau-workbook',
+    '.twbx': 'application/x-tableau-packaged-workbook',
+    '.tds': 'application/x-tableau-datasource',
+    '.tdsx': 'application/x-tableau-packaged-datasource',
+    '.hyper': 'application/x-tableau-hyper',
+    '.tde': 'application/x-tableau-extract',
+    // Database
+    '.sql': 'application/sql',
+    '.db': 'application/x-sqlite3',
+    '.sqlite': 'application/x-sqlite3',
+    '.sqlite3': 'application/x-sqlite3',
+    // Notebooks & Scripts
+    '.ipynb': 'application/x-ipynb+json',
+    '.rmd': 'text/x-r-markdown',
+    '.qmd': 'text/x-quarto-markdown',
+    // E-books
+    '.epub': 'application/epub+zip',
+    '.mobi': 'application/x-mobipocket-ebook',
+    '.azw3': 'application/vnd.amazon.ebook',
+    '.djvu': 'image/vnd.djvu',
+    '.cbz': 'application/vnd.comicbook+zip',
+    '.cbr': 'application/vnd.comicbook-rar',
+    // Fonts
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+};
+export class FilesystemScanner {
+    context;
+    sinceTimestamp;
+    constructor(context) {
+        this.context = context;
+        const sinceDays = context.options.sinceDays ?? 7;
+        this.sinceTimestamp = Date.now() - sinceDays * 24 * 60 * 60 * 1000;
+    }
+    /** Check if file matches exclude patterns */
+    isExcluded(filePath) {
+        return this.context.options.excludePatterns.some((pattern) => minimatch(filePath, pattern, { dot: true }));
+    }
+    /** Check if file matches allowed file types */
+    matchesFileTypes(filePath) {
+        const types = this.context.options.fileTypes;
+        if (!types || types.length === 0)
+            return true;
+        const ext = extname(filePath).toLowerCase();
+        return types.some((t) => t.toLowerCase() === ext);
+    }
+    /** Get MIME type based on extension */
+    getMimeType(ext) {
+        return MIME_MAP[ext.toLowerCase()];
+    }
+    /** Get content preview for text files */
+    getContentPreview(filePath, ext) {
+        if (!this.context.options.includeContent)
+            return undefined;
+        if (!TEXT_EXTENSIONS.has(ext.toLowerCase()))
+            return undefined;
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            if (content.length <= CONTENT_PREVIEW_LENGTH) {
+                return content;
+            }
+            return content.slice(0, CONTENT_PREVIEW_LENGTH) + '...';
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Scan a single directory recursively */
+    scanDirectory(dirPath) {
+        const results = [];
+        let entries;
+        try {
+            entries = readdirSync(dirPath, { withFileTypes: true });
+        }
+        catch (error) {
+            this.context.logger.warn(`Cannot read directory: ${dirPath}`, error);
+            return results;
+        }
+        for (const entry of entries) {
+            const fullPath = resolve(dirPath, entry.name);
+            // Check exclusion patterns
+            if (this.isExcluded(fullPath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                // Skip git repositories entirely
+                if (isGitRepository(fullPath)) {
+                    this.context.logger.debug(`Skipping git repository: ${fullPath}`);
+                    continue;
+                }
+                // Recurse into subdirectory
+                results.push(...this.scanDirectory(fullPath));
+            }
+            else if (entry.isFile()) {
+                // Check file type filter
+                if (!this.matchesFileTypes(fullPath)) {
+                    continue;
+                }
+                try {
+                    const stat = statSync(fullPath);
+                    const mtimeMs = stat.mtimeMs;
+                    // Check if modified within sinceDays
+                    if (mtimeMs < this.sinceTimestamp) {
+                        continue;
+                    }
+                    // Check max file size
+                    const maxSize = this.context.options.maxFileSize;
+                    if (maxSize !== undefined && stat.size > maxSize) {
+                        this.context.logger.debug(`Skipping large file: ${fullPath} (${stat.size} bytes)`);
+                        continue;
+                    }
+                    const ext = extname(fullPath);
+                    results.push({
+                        filePath: fullPath,
+                        fileName: basename(fullPath),
+                        eventType: 'modify', // Stateless mode: all changes are 'modify'
+                        modifiedAt: new Date(mtimeMs).toISOString(),
+                        fileSize: stat.size,
+                        extension: ext,
+                        mimeType: this.getMimeType(ext),
+                        contentPreview: this.getContentPreview(fullPath, ext),
+                        parentDirectory: dirname(fullPath),
+                    });
+                }
+                catch (error) {
+                    this.context.logger.warn(`Cannot stat file: ${fullPath}`, error);
+                }
+            }
+        }
+        return results;
+    }
+    /** Scan all configured watch paths */
+    scan() {
+        const allItems = [];
+        for (const watchPath of this.context.options.watchPaths) {
+            const expandedPath = expandPath(watchPath);
+            try {
+                const stat = statSync(expandedPath);
+                if (!stat.isDirectory()) {
+                    this.context.logger.warn(`Watch path is not a directory: ${watchPath}`);
+                    continue;
+                }
+                // Skip if watchPath itself is a git repository
+                if (isGitRepository(expandedPath)) {
+                    this.context.logger.info(`Skipping git repository: ${watchPath}`);
+                    continue;
+                }
+                this.context.logger.debug(`Scanning: ${expandedPath}`);
+                const items = this.scanDirectory(expandedPath);
+                allItems.push(...items);
+                this.context.logger.debug(`Found ${items.length} files in ${watchPath}`);
+            }
+            catch (error) {
+                this.context.logger.error(`Cannot access watch path: ${watchPath}`, error);
+            }
+        }
+        // Sort by modification time descending
+        allItems.sort((a, b) => new Date(b.modifiedAt).getTime() - new Date(a.modifiedAt).getTime());
+        return allItems;
+    }
+}