watchfix 0.1.0

package/dist/db/queries.js

@@ -0,0 +1,111 @@
+function mapErrorRow(row) {
+    return {
+        id: row.id,
+        hash: row.hash,
+        source: row.source,
+        timestamp: row.timestamp,
+        errorType: row.error_type,
+        message: row.message,
+        stackTrace: row.stack_trace,
+        rawLog: row.raw_log,
+        status: row.status,
+        suggestion: row.suggestion,
+        fixResult: row.fix_result,
+        fixAttempts: row.fix_attempts,
+        lockedBy: row.locked_by,
+        lockedAt: row.locked_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+const ERROR_SELECT_COLUMNS = `
+  id,
+  hash,
+  source,
+  timestamp,
+  error_type,
+  message,
+  stack_trace,
+  raw_log,
+  status,
+  suggestion,
+  fix_result,
+  fix_attempts,
+  locked_by,
+  locked_at,
+  created_at,
+  updated_at
+`;
+export function insertError(db, error) {
+    const now = new Date().toISOString();
+    const createdAt = error.createdAt ?? now;
+    const updatedAt = error.updatedAt ?? createdAt;
+    const status = error.status ?? 'pending';
+    const fixAttempts = error.fixAttempts ?? 0;
+    const result = db.run(`INSERT INTO errors (
+      hash,
+      source,
+      timestamp,
+      error_type,
+      message,
+      stack_trace,
+      raw_log,
+      status,
+      suggestion,
+      fix_result,
+      fix_attempts,
+      locked_by,
+      locked_at,
+      created_at,
+      updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        error.hash,
+        error.source,
+        error.timestamp,
+        error.errorType,
+        error.message,
+        error.stackTrace ?? null,
+        error.rawLog,
+        status,
+        error.suggestion ?? null,
+        error.fixResult ?? null,
+        fixAttempts,
+        error.lockedBy ?? null,
+        error.lockedAt ?? null,
+        createdAt,
+        updatedAt,
+    ]);
+    return Number(result.lastInsertRowid);
+}
+export function getError(db, id) {
+    const row = db.get(`SELECT ${ERROR_SELECT_COLUMNS} FROM errors WHERE id = ?`, [id]);
+    if (!row) {
+        return null;
+    }
+    return mapErrorRow(row);
+}
+export function getErrorByHash(db, hash) {
+    const row = db.get(`SELECT ${ERROR_SELECT_COLUMNS} FROM errors WHERE hash = ? ORDER BY created_at DESC LIMIT 1`, [hash]);
+    if (!row) {
+        return null;
+    }
+    return mapErrorRow(row);
+}
+export function updateErrorStatus(db, id, status) {
+    const result = db.run('UPDATE errors SET status = ?, updated_at = ? WHERE id = ?', [status, new Date().toISOString(), id]);
+    return result.changes > 0;
+}
+export function getErrorsByStatus(db, statuses) {
+    if (statuses.length === 0) {
+        return [];
+    }
+    const placeholders = statuses.map(() => '?').join(', ');
+    const rows = db.all(`SELECT ${ERROR_SELECT_COLUMNS} FROM errors WHERE status IN (${placeholders}) ORDER BY created_at ASC`, statuses);
+    return rows.map(mapErrorRow);
+}
+export function getPendingErrors(db) {
+    return getErrorsByStatus(db, ['pending']);
+}
+export function logActivity(db, action, errorId, details) {
+    db.run('INSERT INTO activity_log (timestamp, action, error_id, details) VALUES (?, ?, ?, ?)', [new Date().toISOString(), action, errorId ?? null, details ?? null]);
+}

package/dist/db/schema.d.ts

@@ -0,0 +1,4 @@
+import type { Database } from './index.js';
+export declare const SCHEMA_VERSION = 1;
+export declare function initializeSchema(db: Database): void;
+export declare function checkSchemaVersion(db: Database): void;

package/dist/db/schema.js

@@ -0,0 +1,84 @@
+import { EXIT_CODES } from '../utils/errors.js';
+export const SCHEMA_VERSION = 1;
+const CREATE_ERRORS_TABLE = `
+CREATE TABLE IF NOT EXISTS errors (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  hash TEXT NOT NULL,
+  source TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  error_type TEXT NOT NULL,
+  message TEXT NOT NULL,
+  stack_trace TEXT,
+  raw_log TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  suggestion TEXT,
+  fix_result TEXT,
+  fix_attempts INTEGER NOT NULL DEFAULT 0,
+  locked_by TEXT,
+  locked_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_errors_hash ON errors(hash);
+CREATE INDEX IF NOT EXISTS idx_errors_status ON errors(status);
+CREATE INDEX IF NOT EXISTS idx_errors_created_at ON errors(created_at);
+`;
+const CREATE_WATCHER_STATE_TABLE = `
+CREATE TABLE IF NOT EXISTS watcher_state (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  pid INTEGER NOT NULL,
+  started_at TEXT NOT NULL,
+  autonomous INTEGER NOT NULL DEFAULT 0,
+  project_root TEXT NOT NULL,
+  command_line TEXT NOT NULL
+);
+`;
+const CREATE_ACTIVITY_LOG_TABLE = `
+CREATE TABLE IF NOT EXISTS activity_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp TEXT NOT NULL,
+  action TEXT NOT NULL,
+  error_id INTEGER,
+  details TEXT,
+  FOREIGN KEY (error_id) REFERENCES errors(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_activity_log_timestamp ON activity_log(timestamp);
+CREATE INDEX IF NOT EXISTS idx_activity_log_error_id ON activity_log(error_id);
+`;
+const CREATE_SCHEMA_VERSION_TABLE = `
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL
+);
+`;
+export function initializeSchema(db) {
+    db.exec('BEGIN');
+    try {
+        db.exec(CREATE_SCHEMA_VERSION_TABLE);
+        db.exec(CREATE_ERRORS_TABLE);
+        db.exec(CREATE_WATCHER_STATE_TABLE);
+        db.exec(CREATE_ACTIVITY_LOG_TABLE);
+        const existing = db.get('SELECT version FROM schema_version LIMIT 1');
+        if (!existing) {
+            db.run('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)', [
+                SCHEMA_VERSION,
+                new Date().toISOString(),
+            ]);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function checkSchemaVersion(db) {
+    const row = db.get('SELECT version FROM schema_version LIMIT 1');
+    if (!row || row.version !== SCHEMA_VERSION) {
+        const found = row ? String(row.version) : 'none';
+        console.error(`Database schema version mismatch. Expected ${SCHEMA_VERSION}, found ${found}.`);
+        process.exit(EXIT_CODES.SCHEMA_MISMATCH);
+    }
+}

package/dist/fixer/context.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from '../config/schema.js';
+import type { ErrorRecord } from '../db/queries.js';
+type GeneratedContext = {
+    path: string;
+    content: string;
+};
+export declare const generateAnalyzeContext: (error: ErrorRecord, config: Config, attempt: number) => GeneratedContext;
+export declare const generateFixContext: (error: ErrorRecord, analysis: string, config: Config, attempt: number) => GeneratedContext;
+export type { GeneratedContext };

package/dist/fixer/context.js

@@ -0,0 +1,361 @@
+import path from 'node:path';
+const CONTEXT_DIR = path.posix.join('.watchfix', 'context');
+const STACK_TRACE_MAX_BYTES = 32 * 1024;
+const STACK_TRACE_SLICE_BYTES = 16 * 1024;
+const STACK_TRACE_TRUNCATION_MARKER = '[...truncated...]';
+const formatDate = (date = new Date()) => date.toISOString().slice(0, 10);
+const sliceUtf8ByBytes = (value, bytes, position) => {
+    const buffer = Buffer.from(value, 'utf8');
+    if (buffer.length <= bytes) {
+        return value;
+    }
+    return position === 'start'
+        ? buffer.subarray(0, bytes).toString('utf8')
+        : buffer.subarray(buffer.length - bytes).toString('utf8');
+};
+const truncateStackTrace = (stackTrace) => {
+    if (Buffer.byteLength(stackTrace, 'utf8') <= STACK_TRACE_MAX_BYTES) {
+        return stackTrace;
+    }
+    const head = sliceUtf8ByBytes(stackTrace, STACK_TRACE_SLICE_BYTES, 'start');
+    const tail = sliceUtf8ByBytes(stackTrace, STACK_TRACE_SLICE_BYTES, 'end');
+    return `${head}\n${STACK_TRACE_TRUNCATION_MARKER}\n${tail}`;
+};
+const sanitizeUtf8 = (value) => {
+    let result = '';
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                result += value[i] + value[i + 1];
+                i += 1;
+                continue;
+            }
+            result += '\uFFFD';
+            continue;
+        }
+        if (code >= 0xdc00 && code <= 0xdfff) {
+            result += '\uFFFD';
+            continue;
+        }
+        result += value[i];
+    }
+    return result;
+};
+const splitRawLog = (error) => {
+    if (!error.rawLog) {
+        return { before: [], after: [] };
+    }
+    const lines = error.rawLog.split('\n');
+    const errorIndex = lines.indexOf(error.message);
+    if (errorIndex < 0) {
+        return { before: lines, after: [] };
+    }
+    const afterStart = errorIndex + 1;
+    const stackLines = error.stackTrace ? error.stackTrace.split('\n') : [];
+    let afterLines = lines.slice(afterStart);
+    if (stackLines.length > 0) {
+        let matchCount = 0;
+        while (matchCount < stackLines.length &&
+            afterLines[matchCount] === stackLines[matchCount]) {
+            matchCount += 1;
+        }
+        if (matchCount > 0) {
+            afterLines = afterLines.slice(matchCount);
+        }
+    }
+    return {
+        before: lines.slice(0, errorIndex),
+        after: afterLines,
+    };
+};
+const buildContextBlock = (beforeLines, errorLines, afterLines, truncatedLineCount) => {
+    const lines = [];
+    if (truncatedLineCount > 0) {
+        lines.push(`[...${truncatedLineCount} lines truncated due to size limit...]`);
+    }
+    lines.push(...beforeLines);
+    lines.push('---ERROR---');
+    lines.push(...errorLines);
+    lines.push('---END ERROR---');
+    lines.push(...afterLines);
+    return lines.join('\n');
+};
+const truncateStackTraceToBytes = (stackTrace, maxBytes) => {
+    if (maxBytes <= 0) {
+        return '';
+    }
+    if (Buffer.byteLength(stackTrace, 'utf8') <= maxBytes) {
+        return stackTrace;
+    }
+    const markerBytes = Buffer.byteLength(STACK_TRACE_TRUNCATION_MARKER, 'utf8');
+    if (maxBytes <= markerBytes) {
+        return sliceUtf8ByBytes(stackTrace, maxBytes, 'start');
+    }
+    const headBytes = Math.max(0, maxBytes - markerBytes - 1);
+    const head = headBytes > 0 ? sliceUtf8ByBytes(stackTrace, headBytes, 'start') : '';
+    return head ? `${head}\n${STACK_TRACE_TRUNCATION_MARKER}` : STACK_TRACE_TRUNCATION_MARKER;
+};
+const buildAnalyzeContent = (options) => {
+    const { projectName, projectRoot, error, attempt, date, stackTrace } = options;
+    const analysisPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-analysis.yaml`);
+    return `# WatchFix Task
+
+## Mode
+analyze
+
+## Project
+- Name: ${projectName}
+- Root: ${projectRoot}
+
+## Error Details
+- ID: ${error.id}
+- Source: ${error.source}
+- Type: ${error.errorType}
+- Detected: ${error.timestamp}
+- Fix Attempts: ${error.fixAttempts}
+
+### Message
+${error.message}
+
+### Stack Trace
+${stackTrace}
+
+### Context (surrounding log lines)
+${options.contextBlock}
+
+## Instructions
+
+1. Investigate the project structure to understand the codebase
+2. Identify the root cause of this error
+3. Determine what files need to be modified
+4. Assess your confidence in the fix
+
+Write your analysis to: \`${analysisPath}\`
+
+Use this exact YAML format:
+\`\`\`yaml
+summary: One sentence summary of the problem
+root_cause: |
+  Detailed explanation of root cause
+  Can be multiple lines
+suggested_fix: |
+  What changes to make
+  Step by step if needed
+files_to_modify:
+  - path/to/file1
+  - path/to/file2
+confidence: high | medium | low
+\`\`\`
+
+## Constraints
+- Do NOT modify any files during analysis
+- If you cannot determine the cause, set confidence to "low"
+- Be specific about file paths relative to project root
+- WARNING: If a fix fails and is retried, any file modifications from previous attempts will persist
+`;
+};
+const buildFixContent = (options) => {
+    const { projectName, projectRoot, error, attempt, date, stackTrace, analysis } = options;
+    const resultPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-result.yaml`);
+    return `# WatchFix Task
+
+## Mode
+fix
+
+## Project
+- Name: ${projectName}
+- Root: ${projectRoot}
+
+## Error Details
+- ID: ${error.id}
+- Source: ${error.source}
+- Type: ${error.errorType}
+- Detected: ${error.timestamp}
+- Fix Attempts: ${error.fixAttempts}
+
+### Message
+${error.message}
+
+### Stack Trace
+${stackTrace}
+
+## Previous Analysis
+${analysis}
+
+## Instructions
+
+1. Read the previous analysis above
+2. Implement the suggested fix
+3. Follow existing code style and conventions
+4. Make minimal, targeted changes
+
+Write your results to: \`${resultPath}\`
+
+Use this exact YAML format:
+\`\`\`yaml
+success: true | false
+summary: One sentence describing what was done
+files_changed:
+  - path: relative/path/to/file
+    change: Description of change made
+notes: |
+  Optional additional notes
+  Can be multiple lines
+\`\`\`
+
+## Constraints
+- Make the smallest change that resolves the issue
+- Do NOT change unrelated code
+- If the fix cannot be applied, set success to false and explain in notes
+- WARNING: If this fix fails verification, the modified files will remain changed for the next retry attempt
+`;
+};
+const resolveProjectRoot = (config) => path.resolve(config.project.root);
+const ensureSizeLimit = (options) => {
+    let truncatedLines = 0;
+    let beforeLines = [...options.beforeLines];
+    let afterLines = [...options.afterLines];
+    let stackTrace = options.stackTrace;
+    let content = options.render(beforeLines, afterLines, stackTrace, truncatedLines);
+    // Phase 1: Remove beforeLines (oldest context first)
+    while (Buffer.byteLength(content, 'utf8') > options.maxBytes &&
+        beforeLines.length > 0) {
+        beforeLines = beforeLines.slice(1);
+        truncatedLines += 1;
+        content = options.render(beforeLines, afterLines, stackTrace, truncatedLines);
+    }
+    // Phase 2: Remove afterLines (if still over limit)
+    while (Buffer.byteLength(content, 'utf8') > options.maxBytes &&
+        afterLines.length > 0) {
+        afterLines = afterLines.slice(0, -1);
+        content = options.render(beforeLines, afterLines, stackTrace, truncatedLines);
+    }
+    // Phase 3: Further truncate stack trace using binary search (if still over)
+    if (Buffer.byteLength(content, 'utf8') > options.maxBytes && stackTrace) {
+        let low = 0;
+        let high = Buffer.byteLength(stackTrace, 'utf8');
+        let best = '';
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const candidate = truncateStackTraceToBytes(stackTrace, mid);
+            const candidateContent = options.render(beforeLines, afterLines, candidate, truncatedLines);
+            if (Buffer.byteLength(candidateContent, 'utf8') <= options.maxBytes) {
+                best = candidate;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        stackTrace = best;
+        content = options.render(beforeLines, afterLines, stackTrace, truncatedLines);
+    }
+    return { content, truncatedLines, beforeLines, afterLines, stackTrace };
+};
+export const generateAnalyzeContext = (error, config, attempt) => {
+    const date = formatDate();
+    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-analyze.md`);
+    const maxBytes = config.cleanup.context_max_size_kb * 1024;
+    const { before, after } = splitRawLog(error);
+    const buildContent = (stackTraceValue, beforeLines, afterLines, truncated) => {
+        const errorLines = [error.message];
+        if (stackTraceValue) {
+            errorLines.push(...stackTraceValue.split('\n'));
+        }
+        return buildAnalyzeContent({
+            projectName: config.project.name,
+            projectRoot: resolveProjectRoot(config),
+            error,
+            attempt,
+            date,
+            stackTrace: stackTraceValue,
+            contextBlock: buildContextBlock(beforeLines, errorLines, afterLines, truncated),
+        });
+    };
+    const stackTrace = truncateStackTrace(error.stackTrace ?? '');
+    const render = (beforeLines, afterLines, stackTraceValue, truncated) => buildContent(stackTraceValue, beforeLines, afterLines, truncated);
+    const { content } = ensureSizeLimit({
+        maxBytes,
+        beforeLines: before,
+        afterLines: after,
+        stackTrace,
+        render,
+    });
+    return {
+        path: contextPath,
+        content: sanitizeUtf8(content),
+    };
+};
+const ensureFixSizeLimit = (options) => {
+    let analysis = options.analysis;
+    let stackTrace = options.stackTrace;
+    let content = options.render(analysis, stackTrace);
+    // Phase 1: Truncate analysis content (from end, preserving summary)
+    if (Buffer.byteLength(content, 'utf8') > options.maxBytes && analysis) {
+        let low = 0;
+        let high = Buffer.byteLength(analysis, 'utf8');
+        let best = '';
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const candidate = sliceUtf8ByBytes(analysis, mid, 'start');
+            const candidateContent = options.render(candidate, stackTrace);
+            if (Buffer.byteLength(candidateContent, 'utf8') <= options.maxBytes) {
+                best = candidate;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        analysis = best;
+        content = options.render(analysis, stackTrace);
+    }
+    // Phase 2: Further truncate stack trace using binary search (if still over)
+    if (Buffer.byteLength(content, 'utf8') > options.maxBytes && stackTrace) {
+        let low = 0;
+        let high = Buffer.byteLength(stackTrace, 'utf8');
+        let best = '';
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const candidate = truncateStackTraceToBytes(stackTrace, mid);
+            const candidateContent = options.render(analysis, candidate);
+            if (Buffer.byteLength(candidateContent, 'utf8') <= options.maxBytes) {
+                best = candidate;
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        stackTrace = best;
+        content = options.render(analysis, stackTrace);
+    }
+    return { content, analysis, stackTrace };
+};
+export const generateFixContext = (error, analysis, config, attempt) => {
+    const date = formatDate();
+    const contextPath = path.posix.join(CONTEXT_DIR, `${date}-error-${error.id}-attempt-${attempt}-fix.md`);
+    const maxBytes = config.cleanup.context_max_size_kb * 1024;
+    const stackTrace = truncateStackTrace(error.stackTrace ?? '');
+    const render = (analysisValue, stackTraceValue) => buildFixContent({
+        projectName: config.project.name,
+        projectRoot: resolveProjectRoot(config),
+        error,
+        attempt,
+        date,
+        stackTrace: stackTraceValue,
+        analysis: analysisValue,
+    });
+    const { content } = ensureFixSizeLimit({
+        maxBytes,
+        analysis,
+        stackTrace,
+        render,
+    });
+    return {
+        path: contextPath,
+        content: sanitizeUtf8(content),
+    };
+};

package/dist/fixer/index.d.ts

@@ -0,0 +1,37 @@
+import type { Agent } from '../agents/types.js';
+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 { AnalysisOutput, FixOutput } from './output.js';
+import { type VerificationResult } from './verifier.js';
+type FixOptions = {
+    analyzeOnly?: boolean;
+    reanalyze?: boolean;
+};
+export type FixResult = {
+    errorId: number;
+    status: ErrorStatus;
+    lockAcquired: boolean;
+    attempts: number;
+    analysis?: AnalysisOutput;
+    fix?: FixOutput;
+    verification?: VerificationResult;
+    message?: string;
+};
+type FixOrchestratorOptions = {
+    agent?: Agent;
+    logger?: Logger;
+    terminalEnabled?: boolean;
+};
+export declare class FixOrchestrator {
+    private readonly db;
+    private readonly config;
+    private readonly logger;
+    private readonly agent;
+    private readonly terminalEnabled;
+    constructor(db: Database, config: Config, options?: FixOrchestratorOptions);
+    fixError(errorId: number, options?: FixOptions): Promise<FixResult>;
+    private processAgentOutput;
+}
+export {};