watchfix 0.1.0

package/dist/config/schema.d.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod';
+declare const durationSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+declare const fileSourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    type: "file";
+}, {
+    path: string;
+    name: string;
+    type: "file";
+}>;
+declare const dockerSourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"docker">;
+    container: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "docker";
+    container: string;
+}, {
+    name: string;
+    type: "docker";
+    container: string;
+}>;
+declare const commandSourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"command">;
+    run: z.ZodString;
+    interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "command";
+    run: string;
+    interval: string;
+}, {
+    name: string;
+    type: "command";
+    run: string;
+    interval: string;
+}>;
+declare const logSourceSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    type: "file";
+}, {
+    path: string;
+    name: string;
+    type: "file";
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"docker">;
+    container: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "docker";
+    container: string;
+}, {
+    name: string;
+    type: "docker";
+    container: string;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"command">;
+    run: z.ZodString;
+    interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "command";
+    run: string;
+    interval: string;
+}, {
+    name: string;
+    type: "command";
+    run: string;
+    interval: string;
+}>]>;
+declare const patternSchema: z.ZodString;
+declare const configSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        name: z.ZodString;
+        root: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        root: string;
+    }, {
+        name: string;
+        root?: string | undefined;
+    }>;
+    agent: z.ZodObject<{
+        provider: z.ZodEnum<["claude", "gemini", "codex"]>;
+        timeout: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stderr_is_progress: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "claude" | "gemini" | "codex";
+        timeout: string;
+        retries: number;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        stderr_is_progress?: boolean | undefined;
+    }, {
+        provider: "claude" | "gemini" | "codex";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        timeout?: string | undefined;
+        retries?: number | undefined;
+        stderr_is_progress?: boolean | undefined;
+    }>;
+    logs: z.ZodObject<{
+        sources: z.ZodEffects<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"file">;
+            path: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            name: string;
+            type: "file";
+        }, {
+            path: string;
+            name: string;
+            type: "file";
+        }>, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"docker">;
+            container: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "docker";
+            container: string;
+        }, {
+            name: string;
+            type: "docker";
+            container: string;
+        }>, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"command">;
+            run: z.ZodString;
+            interval: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        }, {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        }>]>, "many">, ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[], ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[]>;
+        context_lines_before: z.ZodDefault<z.ZodNumber>;
+        context_lines_after: z.ZodDefault<z.ZodNumber>;
+        max_line_buffer: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sources: ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[];
+        context_lines_before: number;
+        context_lines_after: number;
+        max_line_buffer: number;
+    }, {
+        sources: ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[];
+        context_lines_before?: number | undefined;
+        context_lines_after?: number | undefined;
+        max_line_buffer?: number | undefined;
+    }>;
+    verification: z.ZodDefault<z.ZodObject<{
+        test_commands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        test_command_timeout: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        health_checks: z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        health_check_timeout: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        wait_after_fix: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        test_commands: string[];
+        test_command_timeout: string;
+        health_checks: string[];
+        health_check_timeout: string;
+        wait_after_fix: string;
+    }, {
+        test_commands?: string[] | undefined;
+        test_command_timeout?: string | undefined;
+        health_checks?: string[] | undefined;
+        health_check_timeout?: string | undefined;
+        wait_after_fix?: string | undefined;
+    }>>;
+    limits: z.ZodDefault<z.ZodObject<{
+        max_attempts_per_error: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts_per_error: number;
+    }, {
+        max_attempts_per_error?: number | undefined;
+    }>>;
+    cleanup: z.ZodDefault<z.ZodObject<{
+        context_max_age_days: z.ZodDefault<z.ZodNumber>;
+        context_max_size_kb: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        context_max_age_days: number;
+        context_max_size_kb: number;
+    }, {
+        context_max_age_days?: number | undefined;
+        context_max_size_kb?: number | undefined;
+    }>>;
+    patterns: z.ZodDefault<z.ZodObject<{
+        match: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        ignore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        ignore: string[];
+        match: string[];
+    }, {
+        ignore?: string[] | undefined;
+        match?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    project: {
+        name: string;
+        root: string;
+    };
+    agent: {
+        provider: "claude" | "gemini" | "codex";
+        timeout: string;
+        retries: number;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        stderr_is_progress?: boolean | undefined;
+    };
+    logs: {
+        sources: ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[];
+        context_lines_before: number;
+        context_lines_after: number;
+        max_line_buffer: number;
+    };
+    verification: {
+        test_commands: string[];
+        test_command_timeout: string;
+        health_checks: string[];
+        health_check_timeout: string;
+        wait_after_fix: string;
+    };
+    limits: {
+        max_attempts_per_error: number;
+    };
+    cleanup: {
+        context_max_age_days: number;
+        context_max_size_kb: number;
+    };
+    patterns: {
+        ignore: string[];
+        match: string[];
+    };
+}, {
+    project: {
+        name: string;
+        root?: string | undefined;
+    };
+    agent: {
+        provider: "claude" | "gemini" | "codex";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        timeout?: string | undefined;
+        retries?: number | undefined;
+        stderr_is_progress?: boolean | undefined;
+    };
+    logs: {
+        sources: ({
+            path: string;
+            name: string;
+            type: "file";
+        } | {
+            name: string;
+            type: "docker";
+            container: string;
+        } | {
+            name: string;
+            type: "command";
+            run: string;
+            interval: string;
+        })[];
+        context_lines_before?: number | undefined;
+        context_lines_after?: number | undefined;
+        max_line_buffer?: number | undefined;
+    };
+    verification?: {
+        test_commands?: string[] | undefined;
+        test_command_timeout?: string | undefined;
+        health_checks?: string[] | undefined;
+        health_check_timeout?: string | undefined;
+        wait_after_fix?: string | undefined;
+    } | undefined;
+    limits?: {
+        max_attempts_per_error?: number | undefined;
+    } | undefined;
+    cleanup?: {
+        context_max_age_days?: number | undefined;
+        context_max_size_kb?: number | undefined;
+    } | undefined;
+    patterns?: {
+        ignore?: string[] | undefined;
+        match?: string[] | undefined;
+    } | undefined;
+}>;
+type Config = z.infer<typeof configSchema>;
+export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, patternSchema, };
+export type { Config };

package/dist/config/schema.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+const MAX_DURATION_MS = 24 * 60 * 60 * 1000;
+const durationSchema = z
+    .string()
+    .regex(/^\d+[smh]$/, 'Duration must be a number followed by s, m, or h (e.g., "5m", "30s", "1h")')
+    .refine((value) => {
+    const amount = Number.parseInt(value.slice(0, -1), 10);
+    return amount > 0;
+}, 'Duration must be greater than 0')
+    .refine((value) => {
+    const amount = Number.parseInt(value.slice(0, -1), 10);
+    const unit = value.slice(-1);
+    const msByUnit = {
+        s: 1000,
+        m: 60_000,
+        h: 3_600_000,
+    };
+    return amount * msByUnit[unit] <= MAX_DURATION_MS;
+}, 'Duration cannot exceed 24 hours');
+const fileSourceSchema = z.object({
+    name: z.string().min(1),
+    type: z.literal('file'),
+    path: z.string().min(1),
+});
+const dockerSourceSchema = z.object({
+    name: z.string().min(1),
+    type: z.literal('docker'),
+    container: z.string().min(1),
+});
+const commandSourceSchema = z.object({
+    name: z.string().min(1),
+    type: z.literal('command'),
+    run: z.string().min(1),
+    interval: durationSchema,
+});
+const logSourceSchema = z.discriminatedUnion('type', [
+    fileSourceSchema,
+    dockerSourceSchema,
+    commandSourceSchema,
+]);
+const patternSchema = z.string().min(1);
+const configSchema = z.object({
+    project: z.object({
+        name: z.string().min(1),
+        root: z.string().default('.'),
+    }),
+    agent: z.object({
+        provider: z.enum(['claude', 'gemini', 'codex']),
+        timeout: durationSchema.default('5m'),
+        retries: z.number().int().min(0).default(2),
+        command: z.string().optional(),
+        args: z.array(z.string()).optional(),
+        stderr_is_progress: z.boolean().optional(),
+    }),
+    logs: z.object({
+        sources: z
+            .array(logSourceSchema)
+            .min(1)
+            .refine((sources) => {
+            const names = sources.map((source) => source.name);
+            return names.length === new Set(names).size;
+        }, { message: 'Log source names must be unique' }),
+        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),
+    }),
+    verification: z
+        .object({
+        test_commands: z.array(z.string()).default([]),
+        test_command_timeout: durationSchema.default('5m'),
+        health_checks: z
+            .array(z
+            .string()
+            .url()
+            .refine((url) => url.startsWith('http://') || url.startsWith('https://'), { message: 'Health check URL must use http:// or https://' }))
+            .default([]),
+        health_check_timeout: durationSchema.default('10s'),
+        wait_after_fix: durationSchema.default('5s'),
+    })
+        .default({}),
+    limits: z
+        .object({
+        max_attempts_per_error: z.number().int().min(1).default(3),
+    })
+        .default({}),
+    cleanup: z
+        .object({
+        context_max_age_days: z.number().int().min(1).default(7),
+        context_max_size_kb: z.number().int().min(64).default(256),
+    })
+        .default({}),
+    patterns: z
+        .object({
+        match: z.array(patternSchema).default([]),
+        ignore: z.array(patternSchema).default([]),
+    })
+        .default({}),
+});
+export { commandSourceSchema, configSchema, dockerSourceSchema, durationSchema, fileSourceSchema, logSourceSchema, patternSchema, };

package/dist/db/index.d.ts

@@ -0,0 +1,15 @@
+import type { RunResult } from 'better-sqlite3';
+type BindParams = unknown[] | Record<string, unknown>;
+export declare class Database {
+    private readonly dbPath;
+    private db?;
+    constructor(dbPath: string);
+    private ensureDirectory;
+    private ensureOpen;
+    get<T = unknown>(sql: string, params?: BindParams): T | undefined;
+    all<T = unknown>(sql: string, params?: BindParams): T[];
+    run(sql: string, params?: BindParams): RunResult;
+    exec(sql: string): void;
+    close(): void;
+}
+export {};

package/dist/db/index.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import DatabaseDriver from 'better-sqlite3';
+export class Database {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    ensureDirectory() {
+        if (this.dbPath === ':memory:' || this.dbPath.startsWith('file:')) {
+            return;
+        }
+        const directory = path.dirname(this.dbPath);
+        if (directory && directory !== '.' && directory !== path.sep) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+    }
+    ensureOpen() {
+        if (this.db) {
+            return this.db;
+        }
+        this.ensureDirectory();
+        const db = new DatabaseDriver(this.dbPath);
+        db.pragma('journal_mode = WAL');
+        db.pragma('busy_timeout = 5000');
+        db.pragma('synchronous = NORMAL');
+        this.db = db;
+        return db;
+    }
+    get(sql, params) {
+        const statement = this.ensureOpen().prepare(sql);
+        if (params === undefined) {
+            return statement.get();
+        }
+        if (Array.isArray(params)) {
+            return statement.get(...params);
+        }
+        return statement.get(params);
+    }
+    all(sql, params) {
+        const statement = this.ensureOpen().prepare(sql);
+        if (params === undefined) {
+            return statement.all();
+        }
+        if (Array.isArray(params)) {
+            return statement.all(...params);
+        }
+        return statement.all(params);
+    }
+    run(sql, params) {
+        const statement = this.ensureOpen().prepare(sql);
+        if (params === undefined) {
+            return statement.run();
+        }
+        if (Array.isArray(params)) {
+            return statement.run(...params);
+        }
+        return statement.run(params);
+    }
+    exec(sql) {
+        this.ensureOpen().exec(sql);
+    }
+    close() {
+        if (!this.db) {
+            return;
+        }
+        this.db.close();
+        this.db = undefined;
+    }
+}

package/dist/db/queries.d.ts

@@ -0,0 +1,45 @@
+import type { ErrorStatus } from '../utils/errors.js';
+import type { Database } from './index.js';
+export type ErrorRecord = {
+    id: number;
+    hash: string;
+    source: string;
+    timestamp: string;
+    errorType: string;
+    message: string;
+    stackTrace: string | null;
+    rawLog: string;
+    status: ErrorStatus;
+    suggestion: string | null;
+    fixResult: string | null;
+    fixAttempts: number;
+    lockedBy: string | null;
+    lockedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ErrorInsert = {
+    hash: string;
+    source: string;
+    timestamp: string;
+    errorType: string;
+    message: string;
+    stackTrace?: string | null;
+    rawLog: string;
+    status?: ErrorStatus;
+    suggestion?: string | null;
+    fixResult?: string | null;
+    fixAttempts?: number;
+    lockedBy?: string | null;
+    lockedAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type ActivityAction = 'watcher_start' | 'watcher_stop' | 'error_detected' | 'error_deduplicated' | 'analysis_start' | 'analysis_complete' | 'analysis_failed' | 'analysis_timeout' | 'fix_start' | 'fix_complete' | 'fix_failed' | 'fix_timeout' | 'verification_start' | 'verification_pass' | 'verification_fail' | 'error_ignored' | 'lock_acquired' | 'lock_released' | 'lock_expired' | 'stale_recovery';
+export declare function insertError(db: Database, error: ErrorInsert): number;
+export declare function getError(db: Database, id: number): ErrorRecord | null;
+export declare function getErrorByHash(db: Database, hash: string): ErrorRecord | null;
+export declare function updateErrorStatus(db: Database, id: number, status: ErrorStatus): boolean;
+export declare function getErrorsByStatus(db: Database, statuses: ErrorStatus[]): ErrorRecord[];
+export declare function getPendingErrors(db: Database): ErrorRecord[];
+export declare function logActivity(db: Database, action: ActivityAction, errorId?: number, details?: string): void;