watchfix 0.2.0 → 0.2.2

package/README.md

@@ -64,12 +64,28 @@ watchfix watch
 watchfix fix <error-id>
 ```
 
+## Autonomous Mode
+
+For fully automated error fixing without manual approval:
+
+```bash
+watchfix watch --autonomous
+```
+
+In autonomous mode, watchfix automatically dispatches AI agents to fix detected errors. Combine with daemon mode for background operation (Linux/macOS):
+
+```bash
+watchfix watch --daemon --autonomous
+```
+
+**Note:** Manual `watchfix fix` commands are blocked while running in autonomous mode.
+
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
 | `watchfix init` | Create `watchfix.yaml` in current directory |
-| `watchfix watch` | Watch logs in foreground (use `--daemon` for background) |
+| `watchfix watch` | Watch logs in foreground (use `--daemon` for background, `--autonomous` for auto-fix) |
 | `watchfix fix [id]` | Analyze and fix a specific error (or `--all` for all pending) |
 | `watchfix show <id>` | Show full error details and analysis |
 | `watchfix status` | Show watcher state and pending errors |

package/dist/cli/commands/fix.js

@@ -175,6 +175,14 @@ const formatFixOutcome = (result, verbosity, maxAttempts) => {
     }
     else if (!result.fix?.success) {
         lines.push(`Error #${result.errorId}: Agent could not apply fix`);
+        if (result.diagnostic) {
+            // Extract key info from diagnostic
+            const diagLines = result.diagnostic.split('\n');
+            const reason = diagLines.find(l => l.includes('timed out') || l.includes('Exit code'));
+            if (reason) {
+                lines.push(`  Reason: ${reason.trim()}`);
+            }
+        }
     }
     else {
         lines.push(`Error #${result.errorId}: Fix attempt completed`);

package/dist/config/schema.d.ts

@@ -259,6 +259,13 @@ declare const configSchema: z.ZodObject<{
         context_max_age_days?: number | undefined;
         context_max_size_kb?: number | undefined;
     }>>;
+    deduplication: z.ZodDefault<z.ZodObject<{
+        fixed_grace_period: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        fixed_grace_period: string;
+    }, {
+        fixed_grace_period?: string | undefined;
+    }>>;
     patterns: z.ZodDefault<z.ZodObject<{
         match: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         ignore: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -315,6 +322,9 @@ declare const configSchema: z.ZodObject<{
         context_max_age_days: number;
         context_max_size_kb: number;
     };
+    deduplication: {
+        fixed_grace_period: string;
+    };
     patterns: {
         ignore: string[];
         match: string[];
@@ -365,6 +375,9 @@ declare const configSchema: z.ZodObject<{
         context_max_age_days?: number | undefined;
         context_max_size_kb?: number | undefined;
     } | undefined;
+    deduplication?: {
+        fixed_grace_period?: string | undefined;
+    } | undefined;
     patterns?: {
         ignore?: string[] | undefined;
         match?: string[] | undefined;

package/dist/config/schema.js

@@ -89,6 +89,11 @@ const configSchema = z.object({
         context_max_size_kb: z.number().int().min(64).default(256),
     })
         .default({}),
+    deduplication: z
+        .object({
+        fixed_grace_period: durationSchema.default('10m'),
+    })
+        .default({}),
     patterns: z
         .object({
         match: z.array(patternSchema).default([]),

package/dist/fixer/index.d.ts

@@ -18,6 +18,7 @@ export type FixResult = {
     fix?: FixOutput;
     verification?: VerificationResult;
     message?: string;
+    diagnostic?: string;
 };
 type FixOrchestratorOptions = {
     agent?: Agent;

package/dist/fixer/index.js

@@ -246,6 +246,7 @@ export class FixOrchestrator {
                         lockAcquired: true,
                         attempts,
                         message: 'Analysis failed',
+                        diagnostic: analysisResult.diagnostic,
                     };
                 }
             }
@@ -348,6 +349,7 @@ export class FixOrchestrator {
                     attempts,
                     analysis: analysisOutput,
                     message: 'Fix failed',
+                    diagnostic: fixResult.diagnostic,
                 };
             }
             logActivity(this.db, 'verification_start', errorId, JSON.stringify({ attempt: attempts }));

package/dist/watcher/index.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
 import { getErrorByHash, insertError, logActivity } from '../db/queries.js';
+import { parseDuration } from '../utils/duration.js';
 import { Logger } from '../utils/logger.js';
 import { ErrorParser } from './parser.js';
 import { CommandSource } from './sources/command.js';
@@ -186,6 +187,22 @@ export class WatcherOrchestrator {
                 });
                 return;
             }
+            // Deduplicate fixed errors within grace period to prevent re-detection
+            // after a fix when the log file is re-read
+            if (existing && existing.status === 'fixed') {
+                const gracePeriodMs = parseDuration(this.config.deduplication.fixed_grace_period);
+                const fixedAt = new Date(existing.updatedAt).getTime();
+                if (Date.now() - fixedAt < gracePeriodMs) {
+                    logActivity(this.db, 'error_deduplicated', existing.id, `status=${existing.status} grace_period=true`);
+                    this.logger.info(`Deduplicated error ${error.hash} (within grace period after fix)`);
+                    this.emitter.emit('error_deduplicated', {
+                        errorId: existing.id,
+                        error,
+                        status: existing.status,
+                    });
+                    return;
+                }
+            }
             const newId = insertError(this.db, {
                 hash: error.hash,
                 source: error.source,

package/dist/watcher/parser.js

@@ -11,6 +11,14 @@ const CONTINUATION_PATTERNS = [
     /^\s+\.\.\./,
 ];
 const isContinuationLine = (line) => CONTINUATION_PATTERNS.some((pattern) => pattern.test(line));
+const extractCoreMessage = (line) => {
+    // "TypeError: Cannot read..." → "Cannot read..."
+    const colonIndex = line.indexOf(': ');
+    if (colonIndex > 0 && colonIndex < 30) {
+        return line.slice(colonIndex + 2).trim();
+    }
+    return line.trim();
+};
 const truncateLine = (line) => {
     if (line.length <= MAX_LINE_LENGTH) {
         return line;
@@ -58,6 +66,21 @@ export class ErrorParser {
             return;
         }
         if (isError) {
+            // Check if this is the same error with a more specific type
+            if (this.current && this.current.stackLines.length === 0) {
+                const currentCore = extractCoreMessage(this.current.message);
+                const newCore = extractCoreMessage(line);
+                if (currentCore === newCore) {
+                    // Same error - discard shallow entry, use the more detailed one
+                    if (this.flushTimer) {
+                        clearTimeout(this.flushTimer);
+                        this.flushTimer = undefined;
+                    }
+                    this.current = undefined;
+                    this.startError(event, line);
+                    return;
+                }
+            }
             await this.flushCurrent('new_error');
             this.startError(event, line);
             return;

package/dist/watcher/sources/file.js

@@ -125,14 +125,12 @@ export class FileSource {
         }
         const inode = typeof stats.ino === 'number' ? stats.ino : null;
         const mtimeMs = stats.mtimeMs;
-        const shouldForceRead = this.forceRead;
         this.forceRead = false;
         const inodeChanged = this.lastInode !== null && inode !== null && inode !== this.lastInode;
-        const mtimeChanged = this.lastMtimeMs !== null && mtimeMs !== this.lastMtimeMs;
-        if (inodeChanged ||
-            stats.size < this.position ||
-            (shouldForceRead && stats.size === this.position && this.position > 0) ||
-            (mtimeChanged && stats.size === this.position && this.position > 0)) {
+        // Only reset position on actual file replacement (inode change) or truncation (size shrunk)
+        // Do NOT reset on mtime changes without content changes - this prevents re-reading
+        // old errors when the file is touched but no new content is added
+        if (inodeChanged || stats.size < this.position) {
             this.position = 0;
             this.partialLine = '';
         }

package/package.json

@@ -1,7 +1,21 @@
 {
   "name": "watchfix",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "CLI tool that watches logs, detects errors, and dispatches AI agents to fix them",
+  "keywords": [
+    "cli",
+    "log-watcher",
+    "error-detection",
+    "ai",
+    "ai-agent",
+    "automation",
+    "auto-fix",
+    "llm",
+    "devtools",
+    "monitoring",
+    "logs",
+    "debugging"
+  ],
   "type": "module",
   "bin": {
     "watchfix": "./dist/cli/index.js"