watchfix 0.1.0

package/dist/cli/commands/init.js

@@ -0,0 +1,115 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { UserError } from '../../utils/errors.js';
+const AGENT_PROVIDERS = new Set(['claude', 'gemini', 'codex']);
+const buildTemplate = (projectName, provider) => `# watchfix.yaml
+# Generated by watchfix init
+
+project:
+  name: ${projectName}
+  root: .
+
+agent:
+  provider: ${provider}
+  timeout: 5m
+  retries: 2
+  # command: ${provider}
+  # args:
+  #   - --model
+  #   - sonnet
+  #   - --dangerously-skip-permissions
+  #   - -p
+  # stderr_is_progress: false
+
+logs:
+  sources:
+    - name: app
+      type: file
+      path: ./logs/app.log
+
+  # Example docker source:
+  # - name: api
+  #   type: docker
+  #   container: my-app-api
+
+  # Example command source:
+  # - name: compose
+  #   type: command
+  #   run: docker-compose logs --tail=100
+  #   interval: 30s
+
+  context_lines_before: 10
+  context_lines_after: 5
+  max_line_buffer: 10000
+
+verification:
+  test_commands:
+    - npm run lint
+    - npm test
+  test_command_timeout: 5m
+  health_checks:
+    - http://localhost:3000/health
+  health_check_timeout: 10s
+  wait_after_fix: 5s
+
+limits:
+  max_attempts_per_error: 3
+
+cleanup:
+  context_max_age_days: 7
+  context_max_size_kb: 256
+
+patterns:
+  match:
+    - "FATAL:"
+    - "panic:"
+  ignore:
+    - "DeprecationWarning"
+    - "ExperimentalWarning"
+`;
+const ensureGitignore = async (cwd) => {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    let contents = '';
+    try {
+        contents = await fs.readFile(gitignorePath, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const hasEntry = contents
+        .split(/\r?\n/)
+        .some((line) => line.trim() === '.watchfix/');
+    if (hasEntry) {
+        return;
+    }
+    const trimmed = contents.replace(/\s+$/u, '');
+    const prefix = trimmed.length > 0 ? `${trimmed}\n` : '';
+    const updated = `${prefix}.watchfix/\n`;
+    await fs.writeFile(gitignorePath, updated, 'utf8');
+};
+export const initCommand = async (options) => {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, 'watchfix.yaml');
+    const projectName = path.basename(cwd) || 'my-project';
+    const provider = (options.agent ?? 'claude').toLowerCase();
+    if (!AGENT_PROVIDERS.has(provider)) {
+        throw new UserError(`Unknown agent provider: ${options.agent ?? provider}. ` +
+            'Use one of: claude, gemini, codex.');
+    }
+    try {
+        await fs.access(configPath);
+        if (!options.force) {
+            throw new UserError('watchfix.yaml already exists. Use --force to overwrite.');
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const template = buildTemplate(projectName, provider);
+    await fs.writeFile(configPath, template, 'utf8');
+    await ensureGitignore(cwd);
+};

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

@@ -0,0 +1,9 @@
+type LogsOptions = {
+    config?: string;
+    lines?: string | number;
+    tail?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+};
+export declare const logsCommand: (options: LogsOptions) => Promise<void>;
+export {};

package/dist/cli/commands/logs.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../../config/loader.js';
+import { UserError } from '../../utils/errors.js';
+import { DEFAULT_LOG_PATH } from '../../utils/logger.js';
+const DEFAULT_LINES = 50;
+const parseLineCount = (value) => {
+    if (value === undefined) {
+        return DEFAULT_LINES;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value) || value <= 0) {
+            throw new UserError('Line count must be a positive integer.');
+        }
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new UserError('Line count must be a positive integer.');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new UserError('Line count must be a positive integer.');
+    }
+    return parsed;
+};
+const resolveLogPath = (configPath) => {
+    const config = loadConfig(configPath);
+    return path.join(config.project.root, DEFAULT_LOG_PATH);
+};
+const readLogLines = (logPath) => {
+    const contents = fs.readFileSync(logPath, 'utf8');
+    const lines = contents.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+};
+const outputLastLines = (logPath, lineCount) => {
+    const lines = readLogLines(logPath);
+    const startIndex = Math.max(0, lines.length - lineCount);
+    const output = lines.slice(startIndex);
+    if (output.length === 0) {
+        return;
+    }
+    process.stdout.write(`${output.join('\n')}\n`);
+};
+const readNewEntries = (logPath, start) => {
+    const stats = fs.statSync(logPath);
+    if (stats.size < start) {
+        return 0;
+    }
+    if (stats.size === start) {
+        return start;
+    }
+    const length = stats.size - start;
+    const buffer = Buffer.alloc(length);
+    const fd = fs.openSync(logPath, 'r');
+    try {
+        fs.readSync(fd, buffer, 0, length, start);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    process.stdout.write(buffer.toString('utf8'));
+    return stats.size;
+};
+const tailLog = (logPath) => {
+    let position = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+    const watchDir = path.dirname(logPath);
+    const fileName = path.basename(logPath);
+    const watcher = fs.watch(watchDir, { persistent: true }, (event, changed) => {
+        if (changed && changed !== fileName) {
+            return;
+        }
+        if (event === 'rename' && !fs.existsSync(logPath)) {
+            position = 0;
+            return;
+        }
+        try {
+            position = readNewEntries(logPath, position);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                position = 0;
+                return;
+            }
+            throw error;
+        }
+    });
+    process.on('SIGINT', () => {
+        watcher.close();
+    });
+};
+export const logsCommand = async (options) => {
+    const logPath = resolveLogPath(options.config);
+    if (!fs.existsSync(logPath)) {
+        throw new UserError(`No log file found at ${logPath}. Start watchfix watch to create it.`);
+    }
+    const lineCount = parseLineCount(options.lines);
+    outputLastLines(logPath, lineCount);
+    if (options.tail) {
+        tailLog(logPath);
+    }
+};

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

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

package/dist/cli/commands/show.js

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { getError } from '../../db/queries.js';
+import { checkSchemaVersion, initializeSchema } from '../../db/schema.js';
+import { UserError } from '../../utils/errors.js';
+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 parseJsonMaybe = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+};
+const getActivityLog = (db, errorId) => db.all('SELECT id, timestamp, action, error_id, details FROM activity_log WHERE error_id = ? ORDER BY timestamp ASC, id ASC', [errorId]);
+const formatMultiline = (label, value) => {
+    if (!value) {
+        return [`${label}: (none)`];
+    }
+    const lines = value.split('\n');
+    return [`${label}:`, ...lines.map((line) => `  ${line}`)];
+};
+const formatErrorDetails = (error) => [
+    `ID: ${error.id}`,
+    `Hash: ${error.hash}`,
+    `Source: ${error.source}`,
+    `Timestamp: ${error.timestamp}`,
+    `Error type: ${error.errorType}`,
+    `Message: ${error.message}`,
+    `Status: ${error.status}`,
+    `Fix attempts: ${error.fixAttempts}`,
+    `Locked by: ${error.lockedBy ?? '(none)'}`,
+    `Locked at: ${error.lockedAt ?? '(none)'}`,
+    `Created at: ${error.createdAt}`,
+    `Updated at: ${error.updatedAt}`,
+    `Suggestion (raw): ${error.suggestion ?? '(none)'}`,
+    `Fix result (raw): ${error.fixResult ?? '(none)'}`,
+];
+const formatAnalysis = (analysis) => {
+    if (!analysis) {
+        return ['Analysis: (none)'];
+    }
+    if (typeof analysis === 'string') {
+        return ['Analysis (raw):', `  ${analysis}`];
+    }
+    const lines = ['Analysis:'];
+    if (analysis.summary) {
+        lines.push(`  Summary: ${analysis.summary}`);
+    }
+    if (analysis.root_cause) {
+        lines.push('  Root cause:');
+        lines.push(...analysis.root_cause.split('\n').map((line) => `    ${line}`));
+    }
+    if (analysis.suggested_fix) {
+        lines.push('  Suggested fix:');
+        lines.push(...analysis.suggested_fix.split('\n').map((line) => `    ${line}`));
+    }
+    if (analysis.files_to_modify && analysis.files_to_modify.length > 0) {
+        lines.push('  Files to modify:');
+        for (const file of analysis.files_to_modify) {
+            lines.push(`    - ${file}`);
+        }
+    }
+    if (analysis.confidence) {
+        lines.push(`  Confidence: ${analysis.confidence}`);
+    }
+    if (lines.length === 1) {
+        lines.push('  (empty)');
+    }
+    return lines;
+};
+const formatFixResult = (result) => {
+    if (!result) {
+        return ['Fix result: (none)'];
+    }
+    if (typeof result === 'string') {
+        return ['Fix result (raw):', `  ${result}`];
+    }
+    const lines = ['Fix result:'];
+    if (typeof result.success === 'boolean') {
+        lines.push(`  Success: ${result.success ? 'true' : 'false'}`);
+    }
+    if (result.summary) {
+        lines.push(`  Summary: ${result.summary}`);
+    }
+    if (result.files_changed && result.files_changed.length > 0) {
+        lines.push('  Files changed:');
+        for (const file of result.files_changed) {
+            lines.push(`    - ${file.path}: ${file.change}`);
+        }
+    }
+    if (result.notes) {
+        lines.push('  Notes:');
+        lines.push(...result.notes.split('\n').map((line) => `    ${line}`));
+    }
+    if (lines.length === 1) {
+        lines.push('  (empty)');
+    }
+    return lines;
+};
+const formatActivityLog = (entries) => {
+    if (entries.length === 0) {
+        return ['Activity log: (none)'];
+    }
+    const lines = ['Activity log:'];
+    for (const entry of entries) {
+        const details = entry.details ? ` - ${entry.details}` : '';
+        lines.push(`  [${entry.timestamp}] ${entry.action}${details}`.trimEnd());
+    }
+    return lines;
+};
+export const showCommand = 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) {
+            throw new UserError(`Error #${errorId} not found.`);
+        }
+        const analysis = parseJsonMaybe(error.suggestion);
+        const fixResult = parseJsonMaybe(error.fixResult);
+        const activityLog = getActivityLog(db, errorId);
+        if (options.json) {
+            const payload = {
+                error,
+                analysis,
+                fixResult,
+                activityLog,
+            };
+            process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+            return;
+        }
+        const lines = [];
+        lines.push(`Error #${error.id}`);
+        lines.push(...formatErrorDetails(error));
+        lines.push(...formatMultiline('Stack trace', error.stackTrace));
+        lines.push(...formatMultiline('Raw log', error.rawLog));
+        lines.push(...formatAnalysis(analysis));
+        lines.push(...formatFixResult(fixResult));
+        lines.push(...formatActivityLog(activityLog));
+        process.stdout.write(`${lines.join('\n')}\n`);
+    }
+    finally {
+        db.close();
+    }
+};

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

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

package/dist/cli/commands/status.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { getErrorsByStatus } from '../../db/queries.js';
+import { checkSchemaVersion, initializeSchema } from '../../db/schema.js';
+import { isOurProcess } from '../../utils/process.js';
+const STATUS_ORDER = [
+    'pending',
+    'analyzing',
+    'suggested',
+    'fixing',
+    'fixed',
+    'failed',
+    'ignored',
+];
+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 formatUptime = (startedAt) => {
+    const startedMs = Date.parse(startedAt);
+    if (!Number.isFinite(startedMs)) {
+        return 'unknown';
+    }
+    const diffMs = Date.now() - startedMs;
+    if (diffMs < 0) {
+        return 'unknown';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0 || hours > 0) {
+        parts.push(`${minutes}m`);
+    }
+    parts.push(`${seconds}s`);
+    return parts.join(' ');
+};
+const loadStatusCounts = (db) => {
+    const counts = Object.fromEntries(STATUS_ORDER.map((status) => [status, 0]));
+    const rows = db.all('SELECT status, COUNT(*) as count FROM errors GROUP BY status');
+    for (const row of rows) {
+        if (row.status in counts) {
+            counts[row.status] = row.count;
+        }
+    }
+    return counts;
+};
+const formatActionableErrors = (errors) => {
+    if (errors.length === 0) {
+        return ['Actionable errors: none'];
+    }
+    const lines = ['Actionable errors:'];
+    for (const error of errors) {
+        lines.push(`  #${error.id} ${error.errorType} (${error.source}): ${error.message}`);
+    }
+    return lines;
+};
+export const statusCommand = async (options) => {
+    const config = loadConfig(options.config);
+    const dbPath = buildDatabasePath(config.project.root);
+    if (!fs.existsSync(dbPath)) {
+        const lines = [
+            'Watcher: not running.',
+            'Errors:',
+            ...STATUS_ORDER.map((status) => `  ${status}: 0`),
+            'Actionable errors: none',
+        ];
+        process.stdout.write(`${lines.join('\n')}\n`);
+        return;
+    }
+    const db = new Database(dbPath);
+    try {
+        initializeSchema(db);
+        checkSchemaVersion(db);
+        const lines = [];
+        const state = getWatcherState(db);
+        if (state && isOurProcess(state.pid, state.project_root)) {
+            const mode = state.autonomous ? 'autonomous' : 'manual';
+            const uptime = formatUptime(state.started_at);
+            lines.push(`Watcher: running (pid ${state.pid}, ${mode} mode, uptime ${uptime}).`);
+        }
+        else {
+            if (state) {
+                clearWatcherState(db);
+                lines.push('Watcher: not running (cleared stale state).');
+            }
+            else {
+                lines.push('Watcher: not running.');
+            }
+        }
+        const counts = loadStatusCounts(db);
+        lines.push('Errors:');
+        for (const status of STATUS_ORDER) {
+            lines.push(`  ${status}: ${counts[status]}`);
+        }
+        const actionable = getErrorsByStatus(db, ['pending', 'suggested']);
+        lines.push(...formatActionableErrors(actionable));
+        process.stdout.write(`${lines.join('\n')}\n`);
+    }
+    finally {
+        db.close();
+    }
+};

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

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

package/dist/cli/commands/stop.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../../config/loader.js';
+import { Database } from '../../db/index.js';
+import { checkSchemaVersion, initializeSchema } from '../../db/schema.js';
+import { EXIT_CODES, UserError } from '../../utils/errors.js';
+import { isOurProcess } from '../../utils/process.js';
+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 sleep = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
+const isProcessRunning = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const waitForProcessExit = async (pid, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid)) {
+            return true;
+        }
+        await sleep(500);
+    }
+    return !isProcessRunning(pid);
+};
+const formatKillError = (pid, signal, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Failed to send ${signal} to watcher (pid ${pid}): ${message}`;
+};
+const isNoSuchProcessError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    return error.code === 'ESRCH';
+};
+export const stopCommand = async (options) => {
+    const config = loadConfig(options.config);
+    const dbPath = buildDatabasePath(config.project.root);
+    if (!fs.existsSync(dbPath)) {
+        process.stdout.write('No watcher running.\n');
+        process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+        return;
+    }
+    const db = new Database(dbPath);
+    try {
+        initializeSchema(db);
+        checkSchemaVersion(db);
+        const state = getWatcherState(db);
+        if (!state) {
+            process.stdout.write('No watcher running.\n');
+            process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+            return;
+        }
+        if (!isOurProcess(state.pid, state.project_root)) {
+            process.stdout.write('Stale watcher state (process no longer exists).\n');
+            clearWatcherState(db);
+            process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+            return;
+        }
+        process.stdout.write(`Stopping watcher (PID ${state.pid})...\n`);
+        try {
+            process.kill(state.pid, 'SIGTERM');
+        }
+        catch (error) {
+            if (isNoSuchProcessError(error)) {
+                process.stdout.write('Stale watcher state (process already exited).\n');
+                clearWatcherState(db);
+                process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+                return;
+            }
+            throw new UserError(formatKillError(state.pid, 'SIGTERM', error));
+        }
+        const stopped = await waitForProcessExit(state.pid, 30_000);
+        if (!stopped) {
+            process.stdout.write('Watcher did not stop gracefully, forcing...\n');
+            try {
+                process.kill(state.pid, 'SIGKILL');
+            }
+            catch (error) {
+                if (isNoSuchProcessError(error)) {
+                    process.stdout.write('Stale watcher state (process already exited).\n');
+                    clearWatcherState(db);
+                    process.exitCode = EXIT_CODES.WATCHER_CONFLICT;
+                    return;
+                }
+                throw new UserError(formatKillError(state.pid, 'SIGKILL', error));
+            }
+            const killed = await waitForProcessExit(state.pid, 5000);
+            if (!killed) {
+                throw new UserError(`Watcher did not stop after SIGKILL (pid ${state.pid}).`);
+            }
+        }
+        clearWatcherState(db);
+        process.stdout.write('Watcher stopped.\n');
+    }
+    finally {
+        db.close();
+    }
+};

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

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

package/dist/cli/commands/version.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { loadConfig, DEFAULT_CONFIG_PATH } from '../../config/loader.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../../package.json');
+const resolveConfigPath = (configPath) => path.resolve(process.cwd(), configPath ?? DEFAULT_CONFIG_PATH);
+const describeConfigStatus = (configPath) => {
+    const resolvedPath = resolveConfigPath(configPath);
+    if (!fs.existsSync(resolvedPath)) {
+        return { status: 'not found' };
+    }
+    try {
+        const config = loadConfig(resolvedPath);
+        return { status: 'valid', agent: config.agent.provider };
+    }
+    catch (error) {
+        const err = error;
+        return { status: 'invalid', error: err.message ?? String(error) };
+    }
+};
+export const versionCommand = async (options) => {
+    const { status, agent, error } = describeConfigStatus(options.config);
+    const lines = [
+        `${pkg.name ?? 'watchfix'} version: ${pkg.version ?? '0.0.0'}`,
+        `Node.js version: ${process.version}`,
+        `Config: ${status}`,
+    ];
+    if (status !== 'not found') {
+        lines.push(`Agent: ${agent ?? 'unknown (config invalid)'}`);
+    }
+    if (options.verbose && error) {
+        lines.push(`Config error: ${error}`);
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+};

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

@@ -0,0 +1,10 @@
+type WatchOptions = {
+    config?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+    daemon?: boolean;
+    autonomous?: boolean;
+    daemonChild?: boolean;
+};
+export declare const watchCommand: (options: WatchOptions) => Promise<void>;
+export {};