watchfix 0.3.0 → 0.4.0

package/dist/cli/commands/init.js

@@ -27,6 +27,19 @@ logs:
       type: file
       path: ./logs/app.log
 
+  # Example NDJSON source (for structured JSON logs like Pino, Bunyan, Winston):
+  # - name: app-json
+  #   type: file
+  #   path: ./logs/app.ndjson
+  #   format: ndjson
+  #   ndjson:
+  #     messageField: msg           # Required: field containing log message
+  #     timestampField: time        # Optional: field with timestamp
+  #     levelField: level           # Optional: field with log level
+  #     levelFilter:                # Optional: only process these levels
+  #       - error
+  #       - fatal
+
   # Example docker source:
   # - name: api
   #   type: docker

package/dist/config/schema.d.ts

@@ -1,29 +1,76 @@
 import { z } from 'zod';
 declare const durationSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+declare const ndjsonConfigSchema: z.ZodObject<{
+    messageField: z.ZodString;
+    timestampField: z.ZodOptional<z.ZodString>;
+    levelField: z.ZodOptional<z.ZodString>;
+    levelFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    messageField: string;
+    timestampField?: string | undefined;
+    levelField?: string | undefined;
+    levelFilter?: string[] | undefined;
+}, {
+    messageField: string;
+    timestampField?: string | undefined;
+    levelField?: string | undefined;
+    levelFilter?: string[] | undefined;
+}>;
 declare const fileSourceSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodLiteral<"file">;
     path: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<["text", "ndjson"]>>;
+    ndjson: z.ZodOptional<z.ZodObject<{
+        messageField: z.ZodString;
+        timestampField: z.ZodOptional<z.ZodString>;
+        levelField: z.ZodOptional<z.ZodString>;
+        levelFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    }, {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
-    name: string;
     type: "file";
+    name: string;
+    ndjson?: {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    } | undefined;
+    format?: "text" | "ndjson" | undefined;
 }, {
     path: string;
-    name: string;
     type: "file";
+    name: string;
+    ndjson?: {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    } | undefined;
+    format?: "text" | "ndjson" | undefined;
 }>;
 declare const dockerSourceSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodLiteral<"docker">;
     container: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    name: string;
     type: "docker";
+    name: string;
     container: string;
 }, {
-    name: string;
     type: "docker";
+    name: string;
     container: string;
 }>;
 declare const commandSourceSchema: z.ZodObject<{
@@ -32,13 +79,13 @@ declare const commandSourceSchema: z.ZodObject<{
     run: z.ZodString;
     interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
 }, "strip", z.ZodTypeAny, {
-    name: string;
     type: "command";
+    name: string;
     run: string;
     interval: string;
 }, {
-    name: string;
     type: "command";
+    name: string;
     run: string;
     interval: string;
 }>;
@@ -46,25 +93,56 @@ declare const logSourceSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     name: z.ZodString;
     type: z.ZodLiteral<"file">;
     path: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<["text", "ndjson"]>>;
+    ndjson: z.ZodOptional<z.ZodObject<{
+        messageField: z.ZodString;
+        timestampField: z.ZodOptional<z.ZodString>;
+        levelField: z.ZodOptional<z.ZodString>;
+        levelFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    }, {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
-    name: string;
     type: "file";
+    name: string;
+    ndjson?: {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    } | undefined;
+    format?: "text" | "ndjson" | undefined;
 }, {
     path: string;
-    name: string;
     type: "file";
+    name: string;
+    ndjson?: {
+        messageField: string;
+        timestampField?: string | undefined;
+        levelField?: string | undefined;
+        levelFilter?: string[] | undefined;
+    } | undefined;
+    format?: "text" | "ndjson" | undefined;
 }>, z.ZodObject<{
     name: z.ZodString;
     type: z.ZodLiteral<"docker">;
     container: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    name: string;
     type: "docker";
+    name: string;
     container: string;
 }, {
-    name: string;
     type: "docker";
+    name: string;
     container: string;
 }>, z.ZodObject<{
     name: z.ZodString;
@@ -72,13 +150,13 @@ declare const logSourceSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     run: z.ZodString;
     interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
 }, "strip", z.ZodTypeAny, {
-    name: string;
     type: "command";
+    name: string;
     run: string;
     interval: string;
 }, {
-    name: string;
     type: "command";
+    name: string;
     run: string;
     interval: string;
 }>]>;
@@ -117,29 +195,60 @@ declare const configSchema: z.ZodObject<{
         stderr_is_progress?: boolean | undefined;
     }>;
     logs: z.ZodObject<{
-        sources: z.ZodEffects<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        sources: z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             name: z.ZodString;
             type: z.ZodLiteral<"file">;
             path: z.ZodString;
+            format: z.ZodOptional<z.ZodEnum<["text", "ndjson"]>>;
+            ndjson: z.ZodOptional<z.ZodObject<{
+                messageField: z.ZodString;
+                timestampField: z.ZodOptional<z.ZodString>;
+                levelField: z.ZodOptional<z.ZodString>;
+                levelFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            }, {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             path: string;
-            name: string;
             type: "file";
+            name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
         }, {
             path: string;
-            name: string;
             type: "file";
+            name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
         }>, z.ZodObject<{
             name: z.ZodString;
             type: z.ZodLiteral<"docker">;
             container: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            name: string;
             type: "docker";
+            name: string;
             container: string;
         }, {
-            name: string;
             type: "docker";
+            name: string;
             container: string;
         }>, z.ZodObject<{
             name: z.ZodString;
@@ -147,39 +256,93 @@ declare const configSchema: z.ZodObject<{
             run: z.ZodString;
             interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
         }, "strip", z.ZodTypeAny, {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         }, {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         }>]>, "many">, ({
             path: string;
-            name: string;
             type: "file";
-        } | {
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[], ({
             path: string;
-            name: string;
             type: "file";
+            name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
+            type: "docker";
+            name: string;
+            container: string;
         } | {
+            type: "command";
+            name: string;
+            run: string;
+            interval: string;
+        })[]>, ({
+            path: string;
+            type: "file";
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
+            type: "command";
             name: string;
+            run: string;
+            interval: string;
+        })[], ({
+            path: string;
+            type: "file";
+            name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
+            type: "docker";
+            name: string;
+            container: string;
+        } | {
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[]>;
@@ -189,15 +352,22 @@ declare const configSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         sources: ({
             path: string;
-            name: string;
             type: "file";
-        } | {
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[];
@@ -207,15 +377,22 @@ declare const configSchema: z.ZodObject<{
     }, {
         sources: ({
             path: string;
-            name: string;
             type: "file";
-        } | {
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[];
@@ -295,15 +472,22 @@ declare const configSchema: z.ZodObject<{
     logs: {
         sources: ({
             path: string;
-            name: string;
             type: "file";
-        } | {
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[];
@@ -349,15 +533,22 @@ declare const configSchema: z.ZodObject<{
     logs: {
         sources: ({
             path: string;
-            name: string;
             type: "file";
-        } | {
             name: string;
+            ndjson?: {
+                messageField: string;
+                timestampField?: string | undefined;
+                levelField?: string | undefined;
+                levelFilter?: string[] | undefined;
+            } | undefined;
+            format?: "text" | "ndjson" | undefined;
+        } | {
             type: "docker";
+            name: string;
             container: string;
         } | {
-            name: string;
             type: "command";
+            name: string;
             run: string;
             interval: string;
         })[];
@@ -389,5 +580,5 @@ declare const configSchema: z.ZodObject<{
     } | undefined;
 }>;
 type Config = z.infer<typeof configSchema>;
-export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, patternSchema, };
+export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, ndjsonConfigSchema, patternSchema, };
 export type { Config };

package/dist/config/schema.js

@@ -17,10 +17,18 @@ const durationSchema = z
     };
     return amount * msByUnit[unit] <= MAX_DURATION_MS;
 }, 'Duration cannot exceed 24 hours');
+const ndjsonConfigSchema = z.object({
+    messageField: z.string().min(1),
+    timestampField: z.string().min(1).optional(),
+    levelField: z.string().min(1).optional(),
+    levelFilter: z.array(z.string().min(1)).optional(),
+});
 const fileSourceSchema = z.object({
     name: z.string().min(1),
     type: z.literal('file'),
     path: z.string().min(1),
+    format: z.enum(['text', 'ndjson']).optional(),
+    ndjson: ndjsonConfigSchema.optional(),
 });
 const dockerSourceSchema = z.object({
     name: z.string().min(1),
@@ -59,7 +67,15 @@ const configSchema = z.object({
             .refine((sources) => {
             const names = sources.map((source) => source.name);
             return names.length === new Set(names).size;
-        }, { message: 'Log source names must be unique' }),
+        }, { message: 'Log source names must be unique' })
+            .refine((sources) => {
+            return sources.every((source) => {
+                if (source.type === 'file' && source.format === 'ndjson') {
+                    return source.ndjson !== undefined;
+                }
+                return true;
+            });
+        }, { message: 'ndjson config is required when format is "ndjson"' }),
         context_lines_before: z.number().int().min(0).default(10),
         context_lines_after: z.number().int().min(0).default(5),
         max_line_buffer: z.number().int().min(100).default(10000),
@@ -102,4 +118,4 @@ const configSchema = z.object({
     })
         .default({}),
 });
-export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, patternSchema, };
+export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, ndjsonConfigSchema, patternSchema, };

package/dist/watcher/sources/file.d.ts

@@ -9,6 +9,8 @@ export declare class FileSource implements LogSource {
     private readonly filePath;
     private readonly logger;
     private readonly emitter;
+    private readonly format;
+    private readonly ndjsonConfig;
     private watcher;
     private position;
     private partialLine;
@@ -26,5 +28,6 @@ export declare class FileSource implements LogSource {
     private readLoop;
     private readNewLines;
     private processChunk;
+    private handleLine;
 }
 export {};

package/dist/watcher/sources/file.js

@@ -3,11 +3,14 @@ import path from 'node:path';
 import { EventEmitter } from 'node:events';
 import chokidar from 'chokidar';
 import { Logger } from '../../utils/logger.js';
+import { parseNdjsonLine } from './ndjson.js';
 export class FileSource {
     config;
     filePath;
     logger;
     emitter;
+    format;
+    ndjsonConfig;
     watcher = null;
     position = 0;
     partialLine = '';
@@ -23,6 +26,8 @@ export class FileSource {
         this.logger =
             options?.logger ?? new Logger({ terminalEnabled: false, verbosity: 'normal' });
         this.emitter = new EventEmitter();
+        this.format = config.format ?? 'text';
+        this.ndjsonConfig = config.ndjson ?? null;
     }
     async start() {
         if (this.watcher) {
@@ -164,12 +169,40 @@ export class FileSource {
         const lines = combined.split('\n');
         this.partialLine = lines.pop() ?? '';
         for (const rawLine of lines) {
-            const line = rawLine.replace(/\r$/, '');
+            this.handleLine(rawLine.replace(/\r$/, ''));
+        }
+    }
+    handleLine(line) {
+        if (this.format !== 'ndjson' || !this.ndjsonConfig) {
             this.emitter.emit('line', {
                 source: this.config.name,
                 line,
                 timestamp: new Date(),
             });
+            return;
+        }
+        const result = parseNdjsonLine(line, this.ndjsonConfig);
+        if (result.success) {
+            this.emitter.emit('line', {
+                source: this.config.name,
+                line: result.data.message,
+                timestamp: result.data.timestamp,
+            });
+            return;
+        }
+        // Handle different failure reasons
+        if (result.reason === 'filtered') {
+            // Line was filtered by level - silently skip
+            return;
+        }
+        if (result.reason === 'missing_message') {
+            this.logger.debug(`NDJSON line missing message field "${this.ndjsonConfig.messageField}": ${line.slice(0, 100)}`);
         }
+        // For parse errors or missing message, fall back to emitting raw line
+        this.emitter.emit('line', {
+            source: this.config.name,
+            line,
+            timestamp: new Date(),
+        });
     }
 }

package/dist/watcher/sources/ndjson.d.ts

@@ -0,0 +1,16 @@
+import type { NdjsonConfig } from './types.js';
+export type ParsedNdjsonLine = {
+    message: string;
+    timestamp: Date;
+};
+export type NdjsonParseResult = {
+    success: true;
+    data: ParsedNdjsonLine;
+} | {
+    success: false;
+    reason: 'parse_error' | 'missing_message' | 'filtered';
+};
+export declare function getNestedValue(obj: unknown, path: string): unknown;
+export declare function parseTimestamp(value: unknown): Date | null;
+export declare function shouldProcessLevel(value: unknown, levelFilter: string[] | undefined): boolean;
+export declare function parseNdjsonLine(line: string, config: NdjsonConfig): NdjsonParseResult;

package/dist/watcher/sources/ndjson.js

@@ -0,0 +1,108 @@
+export function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function parseTimestamp(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        const date = new Date(value);
+        if (!Number.isNaN(date.getTime())) {
+            return date;
+        }
+        return null;
+    }
+    if (typeof value === 'number') {
+        // Handle Unix timestamps in seconds or milliseconds
+        // If the number is less than 10^12, treat as seconds; otherwise as milliseconds
+        const MS_THRESHOLD = 1e12;
+        const timestamp = value < MS_THRESHOLD ? value * 1000 : value;
+        const date = new Date(timestamp);
+        if (!Number.isNaN(date.getTime())) {
+            return date;
+        }
+        return null;
+    }
+    return null;
+}
+export function shouldProcessLevel(value, levelFilter) {
+    if (!levelFilter || levelFilter.length === 0) {
+        return true;
+    }
+    if (value === null || value === undefined) {
+        // If no level is present but filter is configured, skip the line
+        return false;
+    }
+    // Handle string levels (most common)
+    if (typeof value === 'string') {
+        const lowerValue = value.toLowerCase();
+        return levelFilter.some((filter) => filter.toLowerCase() === lowerValue);
+    }
+    // Handle numeric levels (Bunyan style: 10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal)
+    if (typeof value === 'number') {
+        const bunyanLevels = {
+            10: 'trace',
+            20: 'debug',
+            30: 'info',
+            40: 'warn',
+            50: 'error',
+            60: 'fatal',
+        };
+        const levelName = bunyanLevels[value];
+        if (levelName) {
+            return levelFilter.some((filter) => filter.toLowerCase() === levelName.toLowerCase());
+        }
+        // Unknown numeric level - don't match
+        return false;
+    }
+    return false;
+}
+export function parseNdjsonLine(line, config) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return { success: false, reason: 'parse_error' };
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        return { success: false, reason: 'parse_error' };
+    }
+    // Check level filter first (before extracting message)
+    if (config.levelField) {
+        const levelValue = getNestedValue(parsed, config.levelField);
+        if (!shouldProcessLevel(levelValue, config.levelFilter)) {
+            return { success: false, reason: 'filtered' };
+        }
+    }
+    // Extract message
+    const messageValue = getNestedValue(parsed, config.messageField);
+    if (messageValue === null || messageValue === undefined) {
+        return { success: false, reason: 'missing_message' };
+    }
+    const message = String(messageValue);
+    // Extract timestamp
+    let timestamp = new Date();
+    if (config.timestampField) {
+        const timestampValue = getNestedValue(parsed, config.timestampField);
+        const parsedTimestamp = parseTimestamp(timestampValue);
+        if (parsedTimestamp) {
+            timestamp = parsedTimestamp;
+        }
+    }
+    return {
+        success: true,
+        data: { message, timestamp },
+    };
+}

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

@@ -3,10 +3,18 @@ export type LogEvent = {
     line: string;
     timestamp: Date;
 };
+export type NdjsonConfig = {
+    messageField: string;
+    timestampField?: string;
+    levelField?: string;
+    levelFilter?: string[];
+};
 export type FileSourceConfig = {
     name: string;
     type: 'file';
     path: string;
+    format?: 'text' | 'ndjson';
+    ndjson?: NdjsonConfig;
 };
 export type DockerSourceConfig = {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchfix",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI tool that watches logs, detects errors, and dispatches AI agents to fix them",
   "keywords": [
     "cli",