watchfix 0.1.0

package/dist/cli/commands/watch.js

@@ -0,0 +1,204 @@
+import path from 'node:path';
+import { createAgent } from '../../agents/index.js';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { logActivity } from '../../db/queries.js';
+import { initializeSchema, checkSchemaVersion } from '../../db/schema.js';
+import { FixOrchestrator } from '../../fixer/index.js';
+import { FixQueue } from '../../fixer/queue.js';
+import { WatcherOrchestrator } from '../../watcher/index.js';
+import { daemonize, recoverStaleErrors, setupSignalHandlers, } from '../../utils/daemon.js';
+import { parseDuration } from '../../utils/duration.js';
+import { EXIT_CODES, UserError } from '../../utils/errors.js';
+import { Logger } from '../../utils/logger.js';
+import { isOurProcess } from '../../utils/process.js';
+const resolveVerbosity = (options) => {
+    if (options.quiet) {
+        return 'quiet';
+    }
+    if (options.verbose) {
+        return 'verbose';
+    }
+    return 'normal';
+};
+const buildDatabasePath = (rootDir) => path.join(rootDir, '.watchfix', 'errors.db');
+const getWatcherState = (db) => db.get('SELECT pid, started_at, autonomous, project_root, command_line FROM watcher_state WHERE id = 1');
+const clearWatcherState = (db) => {
+    db.run('DELETE FROM watcher_state WHERE id = 1');
+};
+const ensureWatcherAvailable = (db, projectRoot, logger) => {
+    const existing = getWatcherState(db);
+    if (!existing) {
+        return true;
+    }
+    if (isOurProcess(existing.pid, projectRoot)) {
+        const mode = existing.autonomous ? 'autonomous' : 'manual';
+        const message = `Watcher already running (pid ${existing.pid}, ${mode} mode). Use 'watchfix stop'.`;
+        if (logger) {
+            logger.error(message);
+        }
+        else {
+            console.error(message);
+        }
+        process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+        return false;
+    }
+    clearWatcherState(db);
+    if (logger) {
+        logger.warn('Cleared stale watcher state for non-running process.');
+    }
+    return true;
+};
+const insertWatcherState = (db, options) => {
+    db.run(`INSERT OR REPLACE INTO watcher_state
+     (id, pid, started_at, autonomous, project_root, command_line)
+     VALUES (1, ?, ?, ?, ?, ?)`, [
+        process.pid,
+        new Date().toISOString(),
+        options.autonomous ? 1 : 0,
+        options.projectRoot,
+        process.argv.join(' '),
+    ]);
+};
+const validateDaemonChild = (options) => {
+    const daemonChild = Boolean(options.daemonChild);
+    const envDaemon = process.env.WATCHFIX_DAEMON === '1';
+    if (daemonChild && !envDaemon) {
+        throw new UserError('The --daemon-child flag is internal. Use "watchfix watch --daemon" instead.');
+    }
+    return daemonChild || envDaemon;
+};
+export const watchCommand = async (options) => {
+    const daemonChild = validateDaemonChild(options);
+    if ((options.daemon || daemonChild) && process.platform === 'win32') {
+        throw new UserError('Daemon mode is not supported on Windows.\n' +
+            'Use foreground mode: watchfix watch --autonomous\n' +
+            'Or use a process manager like PM2: pm2 start watchfix -- watch --autonomous');
+    }
+    const config = loadConfig(options.config);
+    const verbosity = resolveVerbosity(options);
+    if (options.daemon && !daemonChild) {
+        const preflightLogger = new Logger({
+            rootDir: config.project.root,
+            terminalEnabled: true,
+            verbosity,
+        });
+        createAgent({
+            provider: config.agent.provider,
+            command: config.agent.command,
+            args: config.agent.args,
+            stderrIsProgress: config.agent.stderr_is_progress,
+            timeout: parseDuration(config.agent.timeout),
+            retries: config.agent.retries,
+        }, {
+            projectRoot: config.project.root,
+            logger: preflightLogger,
+            terminalEnabled: true,
+        });
+        const db = new Database(buildDatabasePath(config.project.root));
+        initializeSchema(db);
+        checkSchemaVersion(db);
+        const available = ensureWatcherAvailable(db, config.project.root, preflightLogger);
+        db.close();
+        if (!available) {
+            return;
+        }
+        const pid = daemonize();
+        process.stdout.write(`Started watchfix daemon (pid ${pid}).\n`);
+        return;
+    }
+    const terminalEnabled = !daemonChild;
+    const logger = new Logger({
+        rootDir: config.project.root,
+        terminalEnabled,
+        verbosity,
+    });
+    const agentConfig = {
+        provider: config.agent.provider,
+        command: config.agent.command,
+        args: config.agent.args,
+        stderrIsProgress: config.agent.stderr_is_progress,
+        timeout: parseDuration(config.agent.timeout),
+        retries: config.agent.retries,
+    };
+    const agentOptions = {
+        projectRoot: config.project.root,
+        logger,
+        terminalEnabled,
+    };
+    let agent;
+    if (options.autonomous) {
+        agent = createAgent(agentConfig, agentOptions);
+    }
+    else {
+        createAgent(agentConfig, agentOptions);
+    }
+    const db = new Database(buildDatabasePath(config.project.root));
+    initializeSchema(db);
+    checkSchemaVersion(db);
+    const available = ensureWatcherAvailable(db, config.project.root, logger);
+    if (!available) {
+        db.close();
+        return;
+    }
+    recoverStaleErrors(db, logger);
+    insertWatcherState(db, {
+        autonomous: Boolean(options.autonomous),
+        projectRoot: config.project.root,
+    });
+    logActivity(db, 'watcher_start', undefined, JSON.stringify({
+        pid: process.pid,
+        autonomous: Boolean(options.autonomous),
+        daemon: daemonChild,
+    }));
+    const watcher = new WatcherOrchestrator(config, db, { logger });
+    let fixQueue = null;
+    let currentFix = null;
+    if (options.autonomous) {
+        const fixOrchestrator = new FixOrchestrator(db, config, {
+            agent,
+            logger,
+            terminalEnabled,
+        });
+        fixQueue = new FixQueue(db, {
+            onProcess: async (error) => {
+                const errorId = error.id;
+                const fixPromise = fixOrchestrator.fixError(errorId);
+                currentFix = {
+                    promise: fixPromise,
+                    abort: () => {
+                        logger.warn('Fix abort requested but not supported for current agent.');
+                    },
+                };
+                try {
+                    await fixPromise;
+                }
+                catch (cause) {
+                    logger.error(`Fix pipeline failed for error ${errorId}: ${cause instanceof Error ? cause.message : String(cause)}`);
+                }
+                finally {
+                    currentFix = null;
+                }
+            },
+        });
+        watcher.on('error_detected', () => {
+            void fixQueue?.processQueueIfReady();
+        });
+    }
+    process.removeAllListeners('SIGINT');
+    setupSignalHandlers({
+        stopWatchers: async () => {
+            await watcher.stop();
+        },
+        getCurrentFix: () => currentFix,
+    }, {
+        logger,
+        db,
+        clearWatcherState: () => clearWatcherState(db),
+    });
+    await watcher.start();
+    if (options.autonomous) {
+        void fixQueue?.processQueueIfReady();
+    }
+    await new Promise(() => { });
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { Command, Option } from 'commander';
+import { createRequire } from 'node:module';
+import { initCommand } from './commands/init.js';
+import { showCommand } from './commands/show.js';
+import { statusCommand } from './commands/status.js';
+import { stopCommand } from './commands/stop.js';
+import { watchCommand } from './commands/watch.js';
+import { fixCommand } from './commands/fix.js';
+import { ignoreCommand } from './commands/ignore.js';
+import { logsCommand } from './commands/logs.js';
+import { configValidateCommand } from './commands/config.js';
+import { cleanCommand } from './commands/clean.js';
+import { versionCommand } from './commands/version.js';
+import { EXIT_CODES, InternalError, UserError } from '../utils/errors.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const addGlobalOptions = (command) => command
+    .option('-c, --config <path>', 'Use alternate config file')
+    .option('--verbose', 'Increase output verbosity')
+    .option('-q, --quiet', 'Suppress non-essential output');
+const registerCommands = (program) => {
+    addGlobalOptions(program
+        .command('init')
+        .description('Create watchfix.yaml in current directory')
+        .option('--agent <provider>', 'Set initial agent provider (claude, gemini, codex)')
+        .option('--force', 'Overwrite existing watchfix.yaml')
+        .action(async (options) => {
+        await initCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('watch')
+        .description('Watch logs in foreground or background')
+        .option('--daemon', 'Watch logs in background (Linux/macOS only)')
+        .option('--autonomous', 'Auto-fix errors without approval')
+        .addOption(new Option('--daemon-child', 'Internal daemon flag').hideHelp())
+        .action(async (options) => {
+        await watchCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('stop')
+        .description('Stop background watcher')
+        .action(async (options) => {
+        await stopCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('status')
+        .description('Show watcher state and pending errors')
+        .action(async (options) => {
+        await statusCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('show')
+        .description('Show full error details and analysis')
+        .argument('<id>', 'Error identifier')
+        .option('--json', 'Output machine-readable JSON')
+        .action(async (id, options) => {
+        await showCommand(id, options);
+    }));
+    addGlobalOptions(program
+        .command('fix')
+        .description('Analyze and fix specific error')
+        .argument('[id]', 'Error identifier')
+        .option('--all', 'Fix all pending/suggested errors sequentially')
+        .option('--confirm-each', 'Prompt for confirmation before each fix')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--analyze-only', "Stop after analysis, don't apply fix")
+        .option('--reanalyze', 'Force re-run analysis even if already suggested')
+        .action(async (id, options) => {
+        await fixCommand(id, options);
+    }));
+    addGlobalOptions(program
+        .command('ignore')
+        .description('Mark error as ignored')
+        .argument('<id>', 'Error identifier')
+        .action(async (id, options) => {
+        await ignoreCommand(id, options);
+    }));
+    addGlobalOptions(program
+        .command('logs')
+        .description('Show activity log')
+        .option('--tail', 'Follow activity log')
+        .option('-n, --lines <count>', 'Number of lines to show', `${50}`)
+        .action(async (options) => {
+        await logsCommand(options);
+    }));
+    const configCommand = addGlobalOptions(program.command('config').description('Configuration utilities'));
+    addGlobalOptions(configCommand
+        .command('validate')
+        .description('Validate configuration file')
+        .action(async (options) => {
+        await configValidateCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('clean')
+        .description('Remove old context files')
+        .option('--dry-run', 'Show what would be removed without deleting')
+        .option('--force', 'Skip confirmation prompt')
+        .action(async (options) => {
+        await cleanCommand(options);
+    }));
+    addGlobalOptions(program
+        .command('version')
+        .description('Show version information')
+        .action(async (options) => {
+        await versionCommand(options);
+    }));
+};
+const program = new Command();
+program
+    .name('watchfix')
+    .description('CLI tool that watches logs, detects errors, and dispatches AI agents to fix them');
+addGlobalOptions(program);
+program
+    .helpOption('-h, --help', 'Show help for command')
+    .version(pkg.version ?? '0.0.0', '-v, --version', 'Show version and exit');
+registerCommands(program);
+const handleError = (error) => {
+    if (error instanceof UserError) {
+        console.error(error.message);
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+        return;
+    }
+    if (error instanceof InternalError) {
+        console.error(error.stack ?? error.message);
+        console.error('An internal error occurred. Please check logs.');
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+        return;
+    }
+    if (error instanceof Error) {
+        console.error(error.message);
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+        return;
+    }
+    console.error('Unknown error occurred.');
+    process.exitCode = EXIT_CODES.GENERAL_ERROR;
+};
+const main = async () => {
+    process.on('SIGINT', () => {
+        process.exit(EXIT_CODES.INTERRUPTED);
+    });
+    try {
+        await program.parseAsync(process.argv);
+        if (!process.exitCode) {
+            process.exitCode = EXIT_CODES.SUCCESS;
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+};
+void main();

package/dist/config/loader.d.ts

@@ -0,0 +1,4 @@
+import { type Config } from './schema.js';
+declare const DEFAULT_CONFIG_PATH = "watchfix.yaml";
+export declare const loadConfig: (configPath?: string) => Config;
+export { DEFAULT_CONFIG_PATH };

package/dist/config/loader.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ZodError } from 'zod';
+import yaml from 'yaml';
+import { configSchema } from './schema.js';
+import { UserError } from '../utils/errors.js';
+const DEFAULT_CONFIG_PATH = 'watchfix.yaml';
+const resolveConfigPath = (configPath) => path.resolve(process.cwd(), configPath ?? DEFAULT_CONFIG_PATH);
+const resolveIfRelative = (baseDir, value) => path.isAbsolute(value) ? value : path.resolve(baseDir, value);
+const resolveConfigPaths = (config, baseDir) => ({
+    ...config,
+    project: {
+        ...config.project,
+        root: resolveIfRelative(baseDir, config.project.root),
+    },
+    logs: {
+        ...config.logs,
+        sources: config.logs.sources.map((source) => {
+            if (source.type !== 'file') {
+                return source;
+            }
+            return {
+                ...source,
+                path: resolveIfRelative(baseDir, source.path),
+            };
+        }),
+    },
+});
+const formatZodError = (error) => {
+    const lines = error.issues.map((issue) => {
+        const pathLabel = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `- ${pathLabel}: ${issue.message}`;
+    });
+    return `Invalid configuration:\n${lines.join('\n')}`;
+};
+const assertProjectRoot = (rootPath) => {
+    try {
+        const stats = fs.statSync(rootPath);
+        if (!stats.isDirectory()) {
+            throw new UserError(`Project root is not a directory: ${rootPath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof UserError) {
+            throw error;
+        }
+        const err = error;
+        if (err.code === 'ENOENT') {
+            throw new UserError(`Project root does not exist: ${rootPath}`);
+        }
+        throw new UserError(`Unable to access project root ${rootPath}: ${err.message ?? String(err)}`);
+    }
+};
+const readConfigFile = (filePath) => {
+    try {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            throw new UserError(`Config file not found at ${filePath}. Create watchfix.yaml or use --config to specify a path.`);
+        }
+        throw new UserError(`Failed to read config file at ${filePath}: ${err.message ?? String(err)}`);
+    }
+};
+const parseConfigYaml = (contents, filePath) => {
+    try {
+        return yaml.parse(contents);
+    }
+    catch (error) {
+        const err = error;
+        throw new UserError(`Failed to parse YAML in ${filePath}: ${err.message ?? String(err)}`);
+    }
+};
+const validateConfig = (rawConfig) => {
+    try {
+        return configSchema.parse(rawConfig);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            throw new UserError(formatZodError(error));
+        }
+        throw error;
+    }
+};
+export const loadConfig = (configPath) => {
+    const resolvedPath = resolveConfigPath(configPath);
+    const fileContents = readConfigFile(resolvedPath);
+    const rawConfig = parseConfigYaml(fileContents, resolvedPath);
+    const parsedConfig = validateConfig(rawConfig);
+    const configDir = path.dirname(resolvedPath);
+    const resolvedConfig = resolveConfigPaths(parsedConfig, configDir);
+    assertProjectRoot(resolvedConfig.project.root);
+    return resolvedConfig;
+};
+export { DEFAULT_CONFIG_PATH };