watchfix 0.1.0

package/dist/utils/process.js

@@ -0,0 +1,146 @@
+import { spawn, spawnSync } from 'node:child_process';
+const CLI_CHECK_TIMEOUT_MS = 5000;
+const KILL_GRACE_PERIOD_MS = 5000;
+function firstLine(text) {
+    return text.trim().split('\n')[0] ?? '';
+}
+function formatSpawnFailure(command, stderr, status) {
+    const trimmed = stderr.trim();
+    if (trimmed) {
+        return trimmed;
+    }
+    return `'${command}' exited with code ${status}`;
+}
+export function checkCliExists(command) {
+    try {
+        const result = spawnSync(command, ['--version'], {
+            encoding: 'utf8',
+            timeout: CLI_CHECK_TIMEOUT_MS,
+            shell: process.platform === 'win32',
+        });
+        if (result.error) {
+            if (result.error.code === 'ENOENT') {
+                return { exists: false, error: `'${command}' not found in PATH` };
+            }
+            return { exists: false, error: result.error.message };
+        }
+        if (typeof result.status === 'number' && result.status !== 0) {
+            return {
+                exists: false,
+                error: formatSpawnFailure(command, result.stderr ?? '', result.status),
+            };
+        }
+        const stdout = result.stdout ?? '';
+        const version = firstLine(stdout);
+        return version
+            ? { exists: true, version }
+            : { exists: true, version: firstLine(result.stderr ?? '') };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return { exists: false, error: error.message };
+        }
+        return { exists: false, error: 'Unknown error' };
+    }
+}
+export async function spawnWithTimeout(command, args, options = {}, timeoutMs) {
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, {
+            ...options,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let resolved = false;
+        const finalize = (result) => {
+            if (resolved) {
+                return;
+            }
+            resolved = true;
+            resolve(result);
+        };
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            const killTimer = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill('SIGKILL');
+                }
+            }, KILL_GRACE_PERIOD_MS);
+            child.once('close', () => clearTimeout(killTimer));
+        }, timeoutMs);
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                stdout += String(data);
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                stderr += String(data);
+            });
+        }
+        child.on('close', (code) => {
+            clearTimeout(timeoutId);
+            finalize({
+                success: code === 0 && !timedOut,
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                timedOut,
+            });
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeoutId);
+            finalize({
+                success: false,
+                stdout,
+                stderr: error.message,
+                exitCode: -1,
+                timedOut: false,
+            });
+        });
+    });
+}
+function readCommandLine(pid) {
+    if (process.platform === 'win32') {
+        const output = spawnSync('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'CommandLine', '/format:list'], { encoding: 'utf8', timeout: CLI_CHECK_TIMEOUT_MS });
+        // Check for wmic failure - fall through to PowerShell
+        if (!output.error && output.status === 0) {
+            const text = `${output.stdout ?? ''}`;
+            const line = text
+                .split('\n')
+                .map((value) => value.trim())
+                .find((value) => value.toLowerCase().startsWith('commandline='));
+            if (line) {
+                return line.slice('commandline='.length);
+            }
+        }
+        // PowerShell fallback (always reachable now)
+        const powerShell = spawnSync('powershell', ['-Command', `(Get-Process -Id ${pid}).CommandLine`], { encoding: 'utf8', timeout: CLI_CHECK_TIMEOUT_MS });
+        return `${powerShell.stdout ?? ''}${powerShell.stderr ?? ''}`.trim();
+    }
+    const result = spawnSync('ps', ['-p', `${pid}`, '-o', 'args='], {
+        encoding: 'utf8',
+        timeout: CLI_CHECK_TIMEOUT_MS,
+    });
+    return `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+}
+export function isOurProcess(pid, expectedRoot) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return false;
+    }
+    try {
+        const cmdline = readCommandLine(pid);
+        if (!cmdline) {
+            return false;
+        }
+        return cmdline.includes('watchfix') && cmdline.includes(expectedRoot);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/watcher/index.d.ts

@@ -0,0 +1,55 @@
+import type { Config } from '../config/schema.js';
+import type { Database } from '../db/index.js';
+import type { ErrorStatus } from '../utils/errors.js';
+import { Logger } from '../utils/logger.js';
+import { type ParsedError } from './parser.js';
+import type { LogEvent } from './sources/types.js';
+export type WatcherDetectedEvent = {
+    errorId: number;
+    error: ParsedError;
+    previousId?: number;
+    previousStatus?: ErrorStatus;
+};
+export type WatcherDeduplicatedEvent = {
+    errorId: number;
+    error: ParsedError;
+    status: ErrorStatus;
+};
+export type WatcherSourceErrorEvent = {
+    source: string;
+    error: Error;
+};
+type WatcherEventName = 'error_detected' | 'error_deduplicated' | 'source_error';
+type WatcherEventPayloads = {
+    error_detected: WatcherDetectedEvent;
+    error_deduplicated: WatcherDeduplicatedEvent;
+    source_error: WatcherSourceErrorEvent;
+};
+export declare class WatcherOrchestrator {
+    private readonly config;
+    private readonly db;
+    private readonly logger;
+    private readonly sources;
+    private readonly eventQueue;
+    private readonly parser;
+    private readonly emitter;
+    private readonly errorQueue;
+    private processingPromise;
+    private started;
+    private noSourceWarningTimer;
+    constructor(config: Config, db: Database, options?: {
+        logger?: Logger;
+    });
+    on<T extends WatcherEventName>(event: T, handler: (payload: WatcherEventPayloads[T]) => void): void;
+    emit(event: LogEvent): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private createSources;
+    private buildSource;
+    private startEventProcessor;
+    private queueErrorHandling;
+    private handleParsedError;
+    private startNoSourceWarnings;
+    private stopNoSourceWarnings;
+}
+export {};

package/dist/watcher/index.js

@@ -0,0 +1,234 @@
+import { EventEmitter } from 'node:events';
+import { getErrorByHash, insertError, logActivity } from '../db/queries.js';
+import { Logger } from '../utils/logger.js';
+import { ErrorParser } from './parser.js';
+import { CommandSource } from './sources/command.js';
+import { DockerSource } from './sources/docker.js';
+import { FileSource } from './sources/file.js';
+const ACTIVE_STATUSES = new Set([
+    'pending',
+    'analyzing',
+    'suggested',
+    'fixing',
+]);
+const NO_SOURCE_WARN_INTERVAL_MS = 60_000;
+class AsyncQueue {
+    buffer = [];
+    resolvers = [];
+    closed = false;
+    push(value) {
+        if (this.closed) {
+            return;
+        }
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+            return;
+        }
+        this.buffer.push(value);
+    }
+    close() {
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            const resolver = this.resolvers.shift();
+            if (resolver) {
+                resolver({ value: undefined, done: true });
+            }
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.buffer.length > 0) {
+                yield this.buffer.shift();
+                continue;
+            }
+            if (this.closed) {
+                return;
+            }
+            const result = await new Promise((resolve) => {
+                this.resolvers.push(resolve);
+            });
+            if (result.done) {
+                return;
+            }
+            yield result.value;
+        }
+    }
+}
+class SerialTaskQueue {
+    pending = Promise.resolve();
+    run(task) {
+        const next = this.pending.then(() => task());
+        this.pending = next.then(() => undefined, () => undefined);
+        return next;
+    }
+}
+export class WatcherOrchestrator {
+    config;
+    db;
+    logger;
+    sources = [];
+    eventQueue = new AsyncQueue();
+    parser;
+    emitter = new EventEmitter();
+    errorQueue = new SerialTaskQueue();
+    processingPromise = null;
+    started = false;
+    noSourceWarningTimer = null;
+    constructor(config, db, options) {
+        this.config = config;
+        this.db = db;
+        this.logger =
+            options?.logger ?? new Logger({ rootDir: config.project.root });
+        this.parser = new ErrorParser({
+            contextLinesBefore: config.logs.context_lines_before,
+            contextLinesAfter: config.logs.context_lines_after,
+            customMatch: config.patterns.match,
+            customIgnore: config.patterns.ignore,
+            logger: this.logger,
+            onError: (error) => this.queueErrorHandling(error),
+        });
+        this.createSources(config.logs.sources);
+    }
+    on(event, handler) {
+        this.emitter.on(event, handler);
+    }
+    emit(event) {
+        this.eventQueue.push(event);
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.processingPromise = this.startEventProcessor();
+        const results = await Promise.allSettled(this.sources.map((entry) => entry.source.start()));
+        let startedCount = 0;
+        results.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                startedCount += 1;
+                return;
+            }
+            const entry = this.sources[index];
+            const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+            this.logger.error(`Failed to start log source '${entry.name}': ${error.message}`);
+            this.emitter.emit('source_error', { source: entry.name, error });
+        });
+        if (startedCount === 0) {
+            this.logger.error('All log sources failed to start. Watcher will continue running.');
+            this.startNoSourceWarnings();
+        }
+        else {
+            this.stopNoSourceWarnings();
+        }
+    }
+    async stop() {
+        if (!this.started) {
+            return;
+        }
+        this.started = false;
+        this.stopNoSourceWarnings();
+        await Promise.allSettled(this.sources.map((entry) => entry.source.stop()));
+        this.eventQueue.close();
+        if (this.processingPromise) {
+            await this.processingPromise;
+            this.processingPromise = null;
+        }
+    }
+    createSources(configs) {
+        configs.forEach((config) => {
+            const source = this.buildSource(config);
+            source.on('line', (event) => this.eventQueue.push(event));
+            this.sources.push({ name: config.name, source });
+        });
+    }
+    buildSource(config) {
+        switch (config.type) {
+            case 'file':
+                return new FileSource(config, { logger: this.logger });
+            case 'docker':
+                return new DockerSource(config, { logger: this.logger });
+            case 'command':
+                return new CommandSource(config, {
+                    logger: this.logger,
+                    maxLineBuffer: this.config.logs.max_line_buffer,
+                });
+            default: {
+                const exhaustive = config;
+                throw new Error(`Unsupported log source type: ${String(exhaustive)}`);
+            }
+        }
+    }
+    async startEventProcessor() {
+        for await (const event of this.eventQueue) {
+            try {
+                await this.parser.processLine(event);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Failed to process log event: ${message}`);
+            }
+        }
+    }
+    queueErrorHandling(error) {
+        return this.errorQueue.run(() => this.handleParsedError(error));
+    }
+    async handleParsedError(error) {
+        try {
+            const existing = getErrorByHash(this.db, error.hash);
+            if (existing && ACTIVE_STATUSES.has(existing.status)) {
+                logActivity(this.db, 'error_deduplicated', existing.id, `status=${existing.status}`);
+                this.logger.info(`Deduplicated error ${error.hash} (status=${existing.status})`);
+                this.emitter.emit('error_deduplicated', {
+                    errorId: existing.id,
+                    error,
+                    status: existing.status,
+                });
+                return;
+            }
+            const newId = insertError(this.db, {
+                hash: error.hash,
+                source: error.source,
+                timestamp: error.timestamp,
+                errorType: error.errorType,
+                message: error.message,
+                stackTrace: error.stackTrace,
+                rawLog: error.rawLog,
+                status: 'pending',
+                fixAttempts: 0,
+                suggestion: null,
+                fixResult: null,
+            });
+            const details = existing ? `recurrence_of=${existing.id}` : undefined;
+            logActivity(this.db, 'error_detected', newId, details);
+            this.logger.info(existing
+                ? `Recurring error detected (${newId}) from ${error.source}`
+                : `New error detected (${newId}) from ${error.source}`);
+            this.emitter.emit('error_detected', {
+                errorId: newId,
+                error,
+                previousId: existing?.id,
+                previousStatus: existing?.status,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.error(`Failed to persist parsed error: ${message}`);
+        }
+    }
+    startNoSourceWarnings() {
+        if (this.noSourceWarningTimer) {
+            return;
+        }
+        this.noSourceWarningTimer = setInterval(() => {
+            this.logger.warn('No log sources are running. Still waiting for sources.');
+        }, NO_SOURCE_WARN_INTERVAL_MS);
+    }
+    stopNoSourceWarnings() {
+        if (!this.noSourceWarningTimer) {
+            return;
+        }
+        clearInterval(this.noSourceWarningTimer);
+        this.noSourceWarningTimer = null;
+    }
+}

package/dist/watcher/parser.d.ts

@@ -0,0 +1,42 @@
+import type { Logger } from '../utils/logger.js';
+export type LogEvent = {
+    source: string;
+    line: string;
+    timestamp: Date;
+};
+export type ParsedError = {
+    source: string;
+    timestamp: string;
+    errorType: string;
+    message: string;
+    stackTrace: string | null;
+    rawLog: string;
+    hash: string;
+};
+export declare class ErrorParser {
+    private readonly contextLinesBefore;
+    private readonly contextLinesAfter;
+    private readonly onError;
+    private readonly customMatch?;
+    private readonly customIgnore?;
+    private readonly logger?;
+    private readonly flushTimeoutMs;
+    private beforeBuffer;
+    private current?;
+    private flushTimer?;
+    private lastSource?;
+    constructor(options?: {
+        contextLinesBefore?: number;
+        contextLinesAfter?: number;
+        onError?: (error: ParsedError) => void | Promise<void>;
+        customMatch?: string[];
+        customIgnore?: string[];
+        logger?: Logger;
+        flushTimeoutMs?: number;
+    });
+    processLine(event: LogEvent): Promise<void>;
+    private startError;
+    private recordBeforeContext;
+    private resetFlushTimer;
+    private flushCurrent;
+}

package/dist/watcher/parser.js

@@ -0,0 +1,162 @@
+import { computeErrorHash } from '../utils/hash.js';
+import { extractErrorType, matchesErrorPattern } from './patterns.js';
+const MAX_LINE_LENGTH = 64 * 1024;
+const TRUNCATION_SUFFIX = '... [truncated]';
+const FLUSH_TIMEOUT_MS = 100;
+const CONTINUATION_PATTERNS = [
+    /^at\s/,
+    /^\s+(at|in)\s/,
+    /^\s+File "/,
+    /^\s+\d+:\d+/,
+    /^\s+\.\.\./,
+];
+const isContinuationLine = (line) => CONTINUATION_PATTERNS.some((pattern) => pattern.test(line));
+const truncateLine = (line) => {
+    if (line.length <= MAX_LINE_LENGTH) {
+        return line;
+    }
+    return `${line.slice(0, MAX_LINE_LENGTH)}${TRUNCATION_SUFFIX}`;
+};
+export class ErrorParser {
+    contextLinesBefore;
+    contextLinesAfter;
+    onError;
+    customMatch;
+    customIgnore;
+    logger;
+    flushTimeoutMs;
+    beforeBuffer = [];
+    current;
+    flushTimer;
+    lastSource;
+    constructor(options) {
+        this.contextLinesBefore = options?.contextLinesBefore ?? 10;
+        this.contextLinesAfter = options?.contextLinesAfter ?? 5;
+        this.onError = options?.onError ?? (() => undefined);
+        this.customMatch = options?.customMatch;
+        this.customIgnore = options?.customIgnore;
+        this.logger = options?.logger;
+        this.flushTimeoutMs = options?.flushTimeoutMs ?? FLUSH_TIMEOUT_MS;
+    }
+    async processLine(event) {
+        if (this.lastSource && this.lastSource !== event.source) {
+            if (this.current) {
+                await this.flushCurrent('source_change');
+            }
+            this.beforeBuffer = [];
+        }
+        this.lastSource = event.source;
+        const line = truncateLine(event.line);
+        const isError = matchesErrorPattern(line, this.customMatch, this.customIgnore);
+        if (!this.current) {
+            if (isError) {
+                this.startError(event, line);
+            }
+            else {
+                this.recordBeforeContext(line);
+            }
+            return;
+        }
+        if (isError) {
+            await this.flushCurrent('new_error');
+            this.startError(event, line);
+            return;
+        }
+        if (this.current.phase === 'stack') {
+            if (isContinuationLine(line)) {
+                this.current.stackLines.push(line);
+                this.current.rawLines.push(line);
+                this.resetFlushTimer();
+                return;
+            }
+            if (this.contextLinesAfter === 0) {
+                await this.flushCurrent('after_complete');
+                this.recordBeforeContext(line);
+                return;
+            }
+            this.current.phase = 'after';
+            this.current.afterRemaining = this.contextLinesAfter;
+            this.current.rawLines.push(line);
+            this.recordBeforeContext(line);
+            this.current.afterRemaining -= 1;
+            this.resetFlushTimer();
+            if (this.current.afterRemaining <= 0) {
+                await this.flushCurrent('after_complete');
+            }
+            return;
+        }
+        this.current.rawLines.push(line);
+        this.recordBeforeContext(line);
+        this.current.afterRemaining -= 1;
+        this.resetFlushTimer();
+        if (this.current.afterRemaining <= 0) {
+            await this.flushCurrent('after_complete');
+        }
+    }
+    startError(event, line) {
+        const contextBefore = this.contextLinesBefore > 0 ? [...this.beforeBuffer] : [];
+        this.beforeBuffer = [];
+        const errorType = extractErrorType(line);
+        this.current = {
+            source: event.source,
+            timestamp: event.timestamp,
+            message: line,
+            errorType,
+            rawLines: [...contextBefore, line],
+            stackLines: [],
+            phase: 'stack',
+            afterRemaining: this.contextLinesAfter,
+        };
+        this.resetFlushTimer();
+    }
+    recordBeforeContext(line) {
+        if (this.contextLinesBefore === 0) {
+            return;
+        }
+        this.beforeBuffer.push(line);
+        if (this.beforeBuffer.length > this.contextLinesBefore) {
+            this.beforeBuffer.shift();
+        }
+    }
+    resetFlushTimer() {
+        if (!this.current) {
+            return;
+        }
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+        }
+        this.flushTimer = setTimeout(() => {
+            void this.flushCurrent('timeout');
+        }, this.flushTimeoutMs);
+    }
+    async flushCurrent(reason) {
+        if (!this.current) {
+            return;
+        }
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        const current = this.current;
+        this.current = undefined;
+        const stackTrace = current.stackLines.length > 0 ? current.stackLines.join('\n') : null;
+        const rawLog = current.rawLines.join('\n');
+        const hash = computeErrorHash(current.source, current.errorType, current.message);
+        try {
+            await this.onError({
+                source: current.source,
+                timestamp: current.timestamp.toISOString(),
+                errorType: current.errorType,
+                message: current.message,
+                stackTrace,
+                rawLog,
+                hash,
+            });
+        }
+        catch (error) {
+            if (this.logger) {
+                this.logger.error(`ErrorParser failed to emit error (${reason}): ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+    }
+}

package/dist/watcher/patterns.d.ts

@@ -0,0 +1,5 @@
+declare const BUILTIN_MATCH_PATTERNS: ReadonlyArray<RegExp>;
+declare const BUILTIN_IGNORE_PATTERNS: ReadonlyArray<RegExp>;
+declare const matchesErrorPattern: (line: string, customMatch?: string[], customIgnore?: string[]) => boolean;
+declare const extractErrorType: (message: string) => string;
+export { BUILTIN_IGNORE_PATTERNS, BUILTIN_MATCH_PATTERNS, extractErrorType, matchesErrorPattern, };