watchfix 0.1.0

package/dist/cli/commands/config.d.ts

@@ -0,0 +1,7 @@
+type ConfigValidateOptions = {
+    config?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+};
+export declare const configValidateCommand: (options: ConfigValidateOptions) => Promise<void>;
+export {};

package/dist/cli/commands/config.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'yaml';
+import { AGENT_DEFAULTS } from '../../agents/defaults.js';
+import { checkCliExists } from '../../utils/process.js';
+import { configSchema } from '../../config/schema.js';
+import { DEFAULT_CONFIG_PATH } from '../../config/loader.js';
+import { UserError } from '../../utils/errors.js';
+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 formatZodErrors = (error) => error.issues.map((issue) => {
+    const pathLabel = issue.path.length > 0 ? issue.path.join('.') : 'root';
+    return `${pathLabel}: ${issue.message}`;
+});
+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 formatCheckSection = (label, entries) => {
+    if (entries.length === 0) {
+        return [];
+    }
+    return [label, ...entries.map((entry) => `  - ${entry}`)];
+};
+const checkAgentCli = (config) => {
+    const defaults = AGENT_DEFAULTS[config.agent.provider];
+    const command = config.agent.command ?? defaults.command;
+    const result = checkCliExists(command);
+    if (!result.exists) {
+        return {
+            info: `Agent CLI: ${command} (not found)`,
+            error: result.error ?? `Agent CLI '${command}' not found`,
+        };
+    }
+    const versionLabel = result.version ? `(${result.version})` : '(version unknown)';
+    return { info: `Agent CLI: ${command} ${versionLabel}` };
+};
+const describeAccessError = (error) => {
+    if (error.code === 'ENOENT') {
+        return 'not found';
+    }
+    if (error.code === 'EACCES') {
+        return 'permission denied';
+    }
+    return error.message ?? String(error);
+};
+const checkLogSourcePaths = (config) => {
+    const warnings = [];
+    for (const source of config.logs.sources) {
+        if (source.type !== 'file') {
+            continue;
+        }
+        try {
+            fs.accessSync(source.path, fs.constants.R_OK);
+        }
+        catch (error) {
+            const detail = describeAccessError(error);
+            warnings.push(`Log source '${source.name}' path not accessible: ${source.path} (${detail})`);
+        }
+    }
+    return warnings;
+};
+export const configValidateCommand = async (options) => {
+    const configPath = resolveConfigPath(options.config);
+    const contents = readConfigFile(configPath);
+    const rawConfig = parseConfigYaml(contents, configPath);
+    const validation = configSchema.safeParse(rawConfig);
+    const errors = [];
+    const warnings = [];
+    const info = [];
+    if (!validation.success) {
+        errors.push(...formatZodErrors(validation.error));
+    }
+    if (validation.success) {
+        const configDir = path.dirname(configPath);
+        const resolvedConfig = resolveConfigPaths(validation.data, configDir);
+        const agentCheck = checkAgentCli(resolvedConfig);
+        info.push(agentCheck.info);
+        if (agentCheck.error) {
+            errors.push(agentCheck.error);
+        }
+        warnings.push(...checkLogSourcePaths(resolvedConfig));
+    }
+    if (errors.length > 0) {
+        const lines = [
+            'Configuration validation failed.',
+            ...formatCheckSection('Errors:', errors),
+            ...formatCheckSection('Warnings:', warnings),
+        ];
+        throw new UserError(lines.join('\n'));
+    }
+    const lines = [
+        'Configuration is valid.',
+        ...info,
+        ...formatCheckSection('Warnings:', warnings),
+    ].filter(Boolean);
+    process.stdout.write(`${lines.join('\n')}\n`);
+};

package/dist/cli/commands/fix.d.ts

@@ -0,0 +1,12 @@
+type FixOptions = {
+    config?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+    all?: boolean;
+    yes?: boolean;
+    analyzeOnly?: boolean;
+    reanalyze?: boolean;
+    confirmEach?: boolean;
+};
+export declare const fixCommand: (id: string | undefined, options: FixOptions) => Promise<void>;
+export {};

package/dist/cli/commands/fix.js

@@ -0,0 +1,391 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { getError, getErrorsByStatus } from '../../db/queries.js';
+import { checkSchemaVersion, initializeSchema } from '../../db/schema.js';
+import { FixOrchestrator } from '../../fixer/index.js';
+import { EXIT_CODES, UserError } from '../../utils/errors.js';
+import { Logger } from '../../utils/logger.js';
+import { isOurProcess } from '../../utils/process.js';
+const FIXABLE_STATUSES = ['pending', 'suggested'];
+const buildDatabasePath = (rootDir) => path.join(rootDir, '.watchfix', 'errors.db');
+const resolveVerbosity = (options) => {
+    if (options.quiet) {
+        return 'quiet';
+    }
+    if (options.verbose) {
+        return 'verbose';
+    }
+    return 'normal';
+};
+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 parsePositiveInt = (value) => {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new UserError('Error id must be a positive integer.');
+    }
+    return parsed;
+};
+const parseStoredAnalysis = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed ||
+            typeof parsed.summary !== 'string' ||
+            typeof parsed.root_cause !== 'string' ||
+            typeof parsed.suggested_fix !== 'string' ||
+            !Array.isArray(parsed.files_to_modify) ||
+            typeof parsed.confidence !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+};
+const formatAnalysisSummary = (analysis) => {
+    const lines = ['Analysis summary:'];
+    lines.push(`  Summary: ${analysis.summary}`);
+    lines.push('  Root cause:');
+    lines.push(...analysis.root_cause.split('\n').map((line) => `    ${line}`));
+    lines.push('  Suggested fix:');
+    lines.push(...analysis.suggested_fix.split('\n').map((line) => `    ${line}`));
+    lines.push('  Files to modify:');
+    if (analysis.files_to_modify.length === 0) {
+        lines.push('    (none)');
+    }
+    else {
+        for (const file of analysis.files_to_modify) {
+            lines.push(`    - ${file}`);
+        }
+    }
+    lines.push(`  Confidence: ${analysis.confidence}`);
+    return lines;
+};
+const promptForConfirmation = async (label) => {
+    if (!process.stdin.isTTY) {
+        throw new UserError('Cannot prompt for confirmation in non-interactive mode. Use --yes to proceed.');
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await rl.question(`${label} [y/N] `);
+        const normalized = answer.trim().toLowerCase();
+        return normalized === 'y' || normalized === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+};
+const formatFixFailure = (result) => {
+    if (result.verification?.failure) {
+        return result.verification.failure.message;
+    }
+    return result.message ?? 'Fix did not complete successfully.';
+};
+const checkDaemonConflict = (db, logger) => {
+    const state = getWatcherState(db);
+    if (!state) {
+        return true;
+    }
+    if (!isOurProcess(state.pid, state.project_root)) {
+        clearWatcherState(db);
+        return true;
+    }
+    if (state.autonomous) {
+        const message = 'Cannot run manual fix while daemon is in autonomous mode.\n' +
+            'The daemon will automatically fix errors.\n' +
+            "Run 'watchfix stop' first if you want manual control.";
+        console.error(message);
+        process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+        return false;
+    }
+    logger.debug('Daemon running in manual mode, proceeding with fix');
+    return true;
+};
+const ensureFixable = (error) => {
+    if (FIXABLE_STATUSES.includes(error.status)) {
+        return null;
+    }
+    if (error.status === 'analyzing' || error.status === 'fixing') {
+        return `Error #${error.id} is currently ${error.status}.`;
+    }
+    return `Error #${error.id} is not in a fixable state (status=${error.status}).`;
+};
+const reportAnalysis = (errorId, analysis, note) => {
+    if (note) {
+        process.stdout.write(`${note}\n`);
+    }
+    if (!analysis) {
+        process.stdout.write(`No analysis available for error #${errorId}.\n`);
+        return;
+    }
+    const lines = [`Error #${errorId}`, ...formatAnalysisSummary(analysis)];
+    process.stdout.write(`${lines.join('\n')}\n`);
+};
+const reportAnalysisFromResult = (db, errorId, result, note) => {
+    const analysis = result.analysis ??
+        parseStoredAnalysis(getError(db, errorId)?.suggestion ?? null);
+    reportAnalysis(errorId, analysis, note);
+};
+const reportFixResult = (result) => {
+    if (!result.lockAcquired) {
+        process.stdout.write(`Skipped error #${result.errorId}: already locked by another process.\n`);
+        return 'skipped';
+    }
+    if (result.status === 'fixed') {
+        process.stdout.write(`✓ Error #${result.errorId} fixed successfully.\n`);
+        return 'fixed';
+    }
+    const message = formatFixFailure(result);
+    process.stdout.write(`✗ Error #${result.errorId} not fixed (status=${result.status}).\n${message}\n`);
+    return 'failed';
+};
+const runSingleFix = async (db, error, options, orchestrator) => {
+    const reanalyze = Boolean(options.reanalyze);
+    const analyzeOnly = Boolean(options.analyzeOnly);
+    const shouldPrompt = !options.yes && !analyzeOnly;
+    let reanalyzeForFix = reanalyze;
+    if (analyzeOnly) {
+        const result = await orchestrator.fixError(error.id, {
+            analyzeOnly: true,
+            reanalyze,
+        });
+        if (!result.lockAcquired) {
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return reportFixResult(result);
+        }
+        if (result.status !== 'suggested') {
+            process.exitCode = EXIT_CODES.GENERAL_ERROR;
+            reportFixResult(result);
+            return 'failed';
+        }
+        reportAnalysis(error.id, result.analysis ??
+            parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null), result.message);
+        return 'analysis';
+    }
+    if (shouldPrompt) {
+        let analysis = parseStoredAnalysis(error.suggestion);
+        let analysisNote;
+        if (error.status === 'pending' || reanalyze) {
+            const analysisResult = await orchestrator.fixError(error.id, {
+                analyzeOnly: true,
+                reanalyze,
+            });
+            if (!analysisResult.lockAcquired) {
+                process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+                return reportFixResult(analysisResult);
+            }
+            analysisNote = analysisResult.message;
+            analysis =
+                analysisResult.analysis ??
+                    parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null);
+            if (analysisResult.status !== 'suggested') {
+                process.exitCode = EXIT_CODES.GENERAL_ERROR;
+                return reportFixResult(analysisResult);
+            }
+            reanalyzeForFix = false;
+        }
+        if (analysis) {
+            reportAnalysis(error.id, analysis, analysisNote);
+        }
+        else if (analysisNote) {
+            process.stdout.write(`${analysisNote}\n`);
+        }
+        const confirmed = await promptForConfirmation(`Apply fix for error #${error.id}?`);
+        if (!confirmed) {
+            process.stdout.write(`Skipped error #${error.id}.\n`);
+            return 'skipped';
+        }
+    }
+    const result = await orchestrator.fixError(error.id, {
+        reanalyze: reanalyzeForFix,
+    });
+    if (!result.lockAcquired) {
+        process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+        return reportFixResult(result);
+    }
+    reportAnalysisFromResult(db, error.id, result);
+    if (result.status !== 'fixed') {
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+    }
+    return reportFixResult(result);
+};
+const runAllFixes = async (db, options, orchestrator) => {
+    const errors = getErrorsByStatus(db, FIXABLE_STATUSES);
+    if (errors.length === 0) {
+        process.stdout.write('No pending or suggested errors to fix.\n');
+        return;
+    }
+    const analyzeOnly = Boolean(options.analyzeOnly);
+    const reanalyze = Boolean(options.reanalyze);
+    const confirmEach = Boolean(options.confirmEach) && !analyzeOnly;
+    let fixedCount = 0;
+    let failedCount = 0;
+    let skippedCount = 0;
+    let analyzedCount = 0;
+    for (const error of errors) {
+        const fixabilityIssue = ensureFixable(error);
+        if (fixabilityIssue) {
+            process.stdout.write(`${fixabilityIssue} Skipping.\n`);
+            skippedCount += 1;
+            continue;
+        }
+        if (analyzeOnly) {
+            const result = await orchestrator.fixError(error.id, {
+                analyzeOnly: true,
+                reanalyze,
+            });
+            if (!result.lockAcquired) {
+                skippedCount += 1;
+                reportFixResult(result);
+                continue;
+            }
+            if (result.status !== 'suggested') {
+                failedCount += 1;
+                reportFixResult(result);
+                continue;
+            }
+            reportAnalysis(error.id, result.analysis ?? parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null), result.message);
+            analyzedCount += 1;
+            continue;
+        }
+        if (confirmEach) {
+            let analysis = parseStoredAnalysis(error.suggestion);
+            let note;
+            let reanalyzeForFix = reanalyze;
+            if (error.status === 'pending' || reanalyze) {
+                const analysisResult = await orchestrator.fixError(error.id, {
+                    analyzeOnly: true,
+                    reanalyze,
+                });
+                if (!analysisResult.lockAcquired) {
+                    skippedCount += 1;
+                    reportFixResult(analysisResult);
+                    continue;
+                }
+                note = analysisResult.message;
+                analysis =
+                    analysisResult.analysis ??
+                        parseStoredAnalysis(getError(db, error.id)?.suggestion ?? null);
+                if (analysisResult.status !== 'suggested') {
+                    failedCount += 1;
+                    reportFixResult(analysisResult);
+                    continue;
+                }
+                reanalyzeForFix = false;
+            }
+            if (analysis) {
+                reportAnalysis(error.id, analysis, note);
+            }
+            else if (note) {
+                process.stdout.write(`${note}\n`);
+            }
+            const confirmed = await promptForConfirmation(`Apply fix for error #${error.id}?`);
+            if (!confirmed) {
+                process.stdout.write(`Skipped error #${error.id}.\n`);
+                skippedCount += 1;
+                continue;
+            }
+            const result = await orchestrator.fixError(error.id, {
+                reanalyze: reanalyzeForFix,
+            });
+            if (!result.lockAcquired) {
+                skippedCount += 1;
+                reportFixResult(result);
+                continue;
+            }
+            if (result.status === 'fixed') {
+                fixedCount += 1;
+            }
+            else {
+                failedCount += 1;
+            }
+            reportFixResult(result);
+            continue;
+        }
+        const result = await orchestrator.fixError(error.id, { reanalyze });
+        if (!result.lockAcquired) {
+            skippedCount += 1;
+            reportFixResult(result);
+            continue;
+        }
+        reportAnalysisFromResult(db, error.id, result);
+        if (result.status === 'fixed') {
+            fixedCount += 1;
+        }
+        else {
+            failedCount += 1;
+        }
+        reportFixResult(result);
+    }
+    const summary = analyzeOnly
+        ? `Analyzed ${analyzedCount} errors, failed ${failedCount}, skipped ${skippedCount}.`
+        : `Summary: fixed ${fixedCount}, failed ${failedCount}, skipped ${skippedCount}.`;
+    process.stdout.write(`${summary}\n`);
+    if (!analyzeOnly && failedCount > 0) {
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+    }
+};
+export const fixCommand = async (id, options) => {
+    if (options.all && id) {
+        throw new UserError('Specify either an error id or --all, not both.');
+    }
+    if (!options.all && !id) {
+        throw new UserError('Error id is required unless --all is specified.');
+    }
+    const config = loadConfig(options.config);
+    const verbosity = resolveVerbosity(options);
+    const logger = new Logger({
+        rootDir: config.project.root,
+        terminalEnabled: true,
+        verbosity,
+    });
+    const dbPath = buildDatabasePath(config.project.root);
+    if (!fs.existsSync(dbPath)) {
+        throw new UserError(`No database found at ${dbPath}. Run watchfix watch to create it.`);
+    }
+    const db = new Database(dbPath);
+    try {
+        initializeSchema(db);
+        checkSchemaVersion(db);
+        if (!checkDaemonConflict(db, logger)) {
+            return;
+        }
+        const orchestrator = new FixOrchestrator(db, config, {
+            logger,
+            terminalEnabled: true,
+        });
+        if (options.all) {
+            await runAllFixes(db, options, orchestrator);
+            return;
+        }
+        const errorId = parsePositiveInt(id);
+        const error = getError(db, errorId);
+        if (!error) {
+            console.error(`Error #${errorId} not found.`);
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return;
+        }
+        const fixabilityIssue = ensureFixable(error);
+        if (fixabilityIssue) {
+            console.error(fixabilityIssue);
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return;
+        }
+        await runSingleFix(db, error, options, orchestrator);
+    }
+    finally {
+        db.close();
+    }
+};

package/dist/cli/commands/ignore.d.ts

@@ -0,0 +1,7 @@
+type IgnoreOptions = {
+    config?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+};
+export declare const ignoreCommand: (id: string, options: IgnoreOptions) => Promise<void>;
+export {};

package/dist/cli/commands/ignore.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { getError, logActivity } from '../../db/queries.js';
+import { checkSchemaVersion, initializeSchema } from '../../db/schema.js';
+import { acquireLock, generateLockId, releaseLock, transitionStatus } from '../../fixer/lock.js';
+import { EXIT_CODES, UserError } from '../../utils/errors.js';
+const IGNORABLE_STATUSES = ['pending', 'suggested', 'failed'];
+const buildDatabasePath = (rootDir) => path.join(rootDir, '.watchfix', 'errors.db');
+const parsePositiveInt = (value) => {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new UserError('Error id must be a positive integer.');
+    }
+    return parsed;
+};
+const ensureIgnorable = (error) => {
+    if (IGNORABLE_STATUSES.includes(error.status)) {
+        return null;
+    }
+    if (error.status === 'analyzing' || error.status === 'fixing') {
+        return `Error #${error.id} is currently ${error.status}.`;
+    }
+    return `Error #${error.id} is not in an ignorable state (status=${error.status}).`;
+};
+export const ignoreCommand = async (id, options) => {
+    const errorId = parsePositiveInt(id);
+    const config = loadConfig(options.config);
+    const dbPath = buildDatabasePath(config.project.root);
+    if (!fs.existsSync(dbPath)) {
+        throw new UserError(`No database found at ${dbPath}. Run watchfix watch to create it.`);
+    }
+    const db = new Database(dbPath);
+    try {
+        initializeSchema(db);
+        checkSchemaVersion(db);
+        const error = getError(db, errorId);
+        if (!error) {
+            console.error(`Error #${errorId} not found.`);
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return;
+        }
+        const ignorableIssue = ensureIgnorable(error);
+        if (ignorableIssue) {
+            console.error(ignorableIssue);
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return;
+        }
+        const lockId = generateLockId();
+        const lockAcquired = await acquireLock(db, errorId, lockId);
+        if (!lockAcquired) {
+            console.error(`Error #${errorId} is locked by another process.`);
+            process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+            return;
+        }
+        try {
+            const updated = transitionStatus(db, errorId, IGNORABLE_STATUSES, 'ignored', lockId);
+            if (!updated) {
+                console.error(`Error #${errorId} could not be ignored because it changed state.`);
+                process.exitCode = EXIT_CODES.NOT_ACTIONABLE;
+                return;
+            }
+            logActivity(db, 'error_ignored', errorId);
+            process.stdout.write(`Ignored error #${errorId}.\n`);
+        }
+        finally {
+            await releaseLock(db, errorId, lockId);
+        }
+    }
+    finally {
+        db.close();
+    }
+};

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,5 @@
+export type InitOptions = {
+    agent?: string;
+    force?: boolean;
+};
+export declare const initCommand: (options: InitOptions) => Promise<void>;