deepdebug-local-agent 1.0.22 → 1.1.0

package/src/adapters/sap/index.js

@@ -0,0 +1,146 @@
+// src/adapters/sap/index.js
+// SapLogAdapter — watches dev_w* and SLOG* files; emits 6-key error events.
+// AD-1 lifecycle, AD-3 polling, AD-4 byte-position dedup, AD-5 per-file ordering.
+
+import { EventEmitter } from 'node:events';
+import { stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { SAP_DEV_W_REGEX, SAP_SLOG_REGEX, normalizeDevWMatch, normalizeSlogMatch } from './sap-parser.js';
+
+const ADAPTER = 'sap';
+
+export class SapLogAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.sapDir = config.sapDir || '/usr/sap/PRD';
+    this.instanceNumber = config.instanceNumber || '00';
+    this.interval = config.interval ?? 5000;
+    this.replayOnStart = config.replayOnStart === true;
+    this._watchers = [];
+    this._offsets = new Map();   // filePath → byte offset
+    this._inodes = new Map();    // filePath → inode
+    this._isRunning = false;
+  }
+
+  get isRunning() { return this._isRunning; }
+
+  async start() {
+    if (this._isRunning) return;
+    this._isRunning = true;
+
+    const workGlob = join(this.sapDir, `D${this.instanceNumber}`, 'work', 'dev_w*');
+    const logGlob = join(this.sapDir, `D${this.instanceNumber}`, 'log', 'SLOG*');
+
+    const watcherOpts = {
+      usePolling: true,
+      interval: this.interval,
+      ignoreInitial: false, // we handle initial ourselves via TAIL seek
+      awaitWriteFinish: false,
+    };
+
+    const wWork = chokidar.watch(workGlob, watcherOpts);
+    const wSlog = chokidar.watch(logGlob, watcherOpts);
+
+    const handle = (filePath, kind) => {
+      // ENOENT-tolerant: stat() inside _readNew handles disappearance.
+      this._readNew(filePath, kind).catch(() => { /* swallow per ENOENT silence rule */ });
+    };
+
+    // 'add' fires for files present at watch start; honor TAIL/replay flag.
+    const onAdd = (kind) => async (filePath) => {
+      if (this.replayOnStart) {
+        this._offsets.set(filePath, 0);
+      } else {
+        try {
+          const st = await stat(filePath);
+          this._offsets.set(filePath, st.size);
+          this._inodes.set(filePath, st.ino);
+          return; // TAIL mode — don't emit pre-existing content
+        } catch { return; }
+      }
+      handle(filePath, kind);
+    };
+
+    wWork.on('add', onAdd('dev_w'));
+    wWork.on('change', (fp) => handle(fp, 'dev_w'));
+    wSlog.on('add', onAdd('slog'));
+    wSlog.on('change', (fp) => handle(fp, 'slog'));
+
+    // chokidar's 'error' events would otherwise bubble; swallow to keep ENOENT silent.
+    wWork.on('error', () => {});
+    wSlog.on('error', () => {});
+
+    this._watchers.push(wWork, wSlog);
+  }
+
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    await Promise.all(this._watchers.map((w) => w.close().catch(() => {})));
+    this._watchers = [];
+    this._offsets.clear();
+    this._inodes.clear();
+  }
+
+  async _readNew(filePath, kind) {
+    let st;
+    try { st = await stat(filePath); } catch { return; } // ENOENT silence
+
+    const lastOffset = this._offsets.get(filePath) ?? 0;
+    const lastInode = this._inodes.get(filePath);
+
+    // Rotation: inode changed OR size shrunk → reset to 0
+    if ((lastInode !== undefined && st.ino !== lastInode) || st.size < lastOffset) {
+      this._offsets.set(filePath, 0);
+      this._inodes.set(filePath, st.ino);
+      return this._readNew(filePath, kind); // re-enter with offset=0
+    }
+    this._inodes.set(filePath, st.ino);
+
+    if (st.size <= lastOffset) return;
+
+    const fh = await open(filePath, 'r');
+    try {
+      const len = st.size - lastOffset;
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, lastOffset);
+      this._offsets.set(filePath, st.size);
+      // Tolerate CRLF and LF; split, drop trailing empty (no event for blank lines per AD-6 SAP empty-line trap).
+      const text = buf.toString('utf8');
+      const lines = text.split(/\r?\n/);
+      const sourceDir = filePath.split('/').slice(0, -1).join('/');
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        this._tryEmit(line, filePath, sourceDir, kind);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+
+  _tryEmit(line, filePath, sourceDir, kind) {
+    let errorCode = null;
+    if (kind === 'dev_w') {
+      const m = line.match(SAP_DEV_W_REGEX);
+      errorCode = normalizeDevWMatch(m);
+    } else if (kind === 'slog') {
+      const m = line.match(SAP_SLOG_REGEX);
+      errorCode = normalizeSlogMatch(m);
+    }
+    if (errorCode === null) return; // no recognizable code → no event
+
+    // 6-key frozen event payload (AD-4 contract — extra keys forbidden)
+    const event = Object.freeze({
+      adapter: ADAPTER,
+      errorCode,
+      file: filePath,
+      message: line,
+      source: sourceDir,
+      timestamp: new Date().toISOString(),
+    });
+    this.emit('error', event);
+  }
+}
+
+export default SapLogAdapter;

package/src/adapters/sap/sap-parser.js

@@ -0,0 +1,41 @@
+// src/adapters/sap/sap-parser.js
+// T-2-03 mitigation: regexes exported as named constants for isolated testing.
+// Adapter binds chokidar to dev_w* and SLOG* file globs only; these regexes
+// never run against arbitrary text by the adapter itself.
+
+// Matches ABAP work-process trace error lines:
+//   "M  *** ERROR => Runtime error CONVT_NO_NUMBER"
+//   "M  *** ERROR => Exception condition CX_SY_OPEN_SQL_DB raised"
+//   "B  *** ERROR => SQL error in SELECT, sy-subrc = 4"
+export const SAP_DEV_W_REGEX = /\*\*\* ERROR =>\s+(?:Runtime error|Exception condition|SQL error in [A-Z]+,)\s*([A-Z_]+(?:[A-Z_0-9]*)|sy-subrc\s*=\s*\d+)/i;
+
+// Matches SLOG pipe-delimited error/fatal records:
+//   "| 2024-01-15 09:12:44 | E | 04 | Database error..., sy-subrc = 4 |"
+//   "| 2024-01-15 14:01:55 | F | 22 | Short dump 4815162343 created |"
+export const SAP_SLOG_REGEX = /^\|\s*\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\s*\|\s*([EF])\s*\|\s*\d+\s*\|\s*(.+?)\s*\|/;
+
+// Normalizes captured payload to errorCode string (or null when no recognizable code).
+export function normalizeDevWMatch(match) {
+  if (!match) return null;
+  const raw = (match[1] || '').trim();
+  if (/^sy-subrc/i.test(raw)) {
+    const m = raw.match(/=\s*(\d+)/);
+    return m ? `SY-SUBRC=${m[1]}` : 'SY-SUBRC';
+  }
+  return raw.toUpperCase();
+}
+
+export function normalizeSlogMatch(match) {
+  if (!match) return null;
+  const body = (match[2] || '').trim();
+  // Try to extract a known runtime-error keyword from the SLOG message body
+  const m = body.match(/(CONVT_NO_NUMBER|CX_SY_OPEN_SQL_DB|sy-subrc\s*=\s*\d+|Short dump \d+)/i);
+  if (!m) return null;
+  const cap = m[1].trim();
+  if (/^sy-subrc/i.test(cap)) {
+    const num = cap.match(/=\s*(\d+)/);
+    return num ? `SY-SUBRC=${num[1]}` : 'SY-SUBRC';
+  }
+  if (/^Short dump/i.test(cap)) return 'SHORT_DUMP';
+  return cap.toUpperCase();
+}

package/src/ai-engine.js

@@ -1,6 +1,6 @@
 // ============================================
 // 🧠 AI VIBE CODING ENGINE
-// Ficheiro: ai-engine.js
+// File: ai-engine.js
 // Coloca em: ~/deepdebug-local-agent/src/ai-engine.js
 // ============================================
 
@@ -15,15 +15,15 @@ const execAsync = promisify(exec);
 /**
  * AIVibeCodingEngine
  *
- * Sistema universal de auto-healing que usa AI para resolver
- * QUALQUER erro automaticamente - não apenas startup.
+ * Universal auto-healing system that uses AI to resolve
+ * ANY error automatically - not just startup.
  *
  * Features:
- * - Monitorização de erros em tempo real
- * - Classificação automática de erros
+ * - Real-time error monitoring
+ * - Automatic error classification
  * - Quick fixes locais (sem chamar AI)
- * - Escala para AI quando quick fixes falham
- * - Histórico de fixes para reutilização
+ * - Escalates to AI when quick fixes fail
+ * - Fix history for reuse
  */
 export class AIVibeCodingEngine extends EventEmitter {
     constructor(processManager, getWorkspaceRoot) {
@@ -34,12 +34,12 @@ export class AIVibeCodingEngine extends EventEmitter {
         this.maxRetries = 3;
         this.isActive = true;
 
-        // Histórico
+        // History
         this.errorHistory = [];
         this.fixHistory = [];
         this.pendingFixes = [];
 
-        // Estado
+        // State
         this.currentSession = null;
         this.lastSuccessfulConfig = null;
 
@@ -54,14 +54,14 @@ export class AIVibeCodingEngine extends EventEmitter {
     // ============================================
 
     setupErrorMonitoring() {
-        // Monitorar logs do ProcessManager
+        // Monitor ProcessManager logs
         this.processManager.on('log', async ({ serviceId, message, type }) => {
             if (this.isActive && message && this.isError(message)) {
                 await this.handleRuntimeError(serviceId, message, type);
             }
         });
 
-        // Monitorar crashes
+        // Monitor crashes
         this.processManager.on('stopped', async ({ serviceId, code, signal }) => {
             if (this.isActive && code !== 0 && code !== null) {
                 console.log(`🧠 [AI-Engine] Process ${serviceId} crashed (code: ${code})`);
@@ -69,7 +69,7 @@ export class AIVibeCodingEngine extends EventEmitter {
             }
         });
 
-        // Monitorar erros de processo
+        // Monitor process errors
         this.processManager.on('error', async ({ serviceId, error }) => {
             if (this.isActive) {
                 console.log(`🧠 [AI-Engine] Process error: ${error}`);
@@ -212,7 +212,7 @@ export class AIVibeCodingEngine extends EventEmitter {
     async handleRuntimeError(serviceId, errorMessage, type) {
         const classification = this.classifyError(errorMessage);
 
-        // Debounce: evitar duplicatas em 5 segundos
+        // Debounce: avoid duplicates within 5 seconds
         const recentSimilar = this.errorHistory.find(e =>
             e.classification.type === classification.type &&
             Date.now() - e.timestamp < 5000
@@ -235,10 +235,10 @@ export class AIVibeCodingEngine extends EventEmitter {
         console.log(`🧠 [AI-Engine] Error detected: ${classification.type} (${classification.severity})`);
         console.log(`   Message: ${errorMessage.substring(0, 150)}...`);
 
-        // Emitir evento
+        // Emit the event
         this.emit('error_detected', errorEntry);
 
-        // Se auto-fixável, preparar fix
+        // If auto-fixable, prepare a fix
         if (classification.autoFixable) {
             const quickFix = this.getQuickFix(classification.type, errorMessage);
             if (quickFix) {
@@ -357,14 +357,14 @@ export class AIVibeCodingEngine extends EventEmitter {
             attempts++;
             console.log(`\n🔄 [AI-Engine] Attempt ${attempts}/${this.maxRetries}`);
 
-            // Aplicar fixes pendentes
+            // Apply pending fixes
             if (attempts > 1 && this.pendingFixes.length > 0) {
                 const fix = this.pendingFixes.shift();
                 console.log(`💡 [AI-Engine] Applying fix: ${fix.fix.description}`);
                 currentConfig = await this.applyFix(currentConfig, fix.fix);
             }
 
-            // Recompilar se necessário
+            // Recompile if needed
             if (currentConfig.recompile) {
                 console.log('🔨 [AI-Engine] Recompiling...');
                 const compileResult = await this.recompile();
@@ -379,7 +379,7 @@ export class AIVibeCodingEngine extends EventEmitter {
                 delete currentConfig.recompile;
             }
 
-            // Tentar iniciar
+            // Try to start
             const result = await this.attemptStart(currentConfig);
 
             this.currentSession.attempts.push({
@@ -419,14 +419,14 @@ export class AIVibeCodingEngine extends EventEmitter {
             lastError = result.error;
             console.log(`❌ [AI-Engine] Attempt ${attempts} failed: ${lastError?.substring(0, 100)}...`);
 
-            // Obter fix
+            // Get a fix
             const fix = await this.getFix(result.error, result.logs, currentConfig);
 
             if (fix) {
                 console.log(`💡 [AI-Engine] Fix: ${fix.description}`);
                 currentConfig = await this.applyFix(currentConfig, fix);
             } else {
-                // Tentar AI
+                // Try AI
                 console.log(`🤖 [AI-Engine] Requesting AI analysis...`);
                 const aiAnalysis = await this.analyzeWithAI('startup', lastError, currentConfig);
                 if (aiAnalysis?.newConfig) {
@@ -536,7 +536,7 @@ export class AIVibeCodingEngine extends EventEmitter {
             return quickFix;
         }
 
-        // Verificar histórico
+        // Check the history
         const similarFix = this.findSimilarFix(classification.type);
         if (similarFix) {
             console.log(`📚 [AI-Engine] Found similar fix in history`);
@@ -707,7 +707,7 @@ export class AIVibeCodingEngine extends EventEmitter {
         }
 
         try {
-            // Importar detectProject dinamicamente para evitar dependência circular
+            // Import detectProject dynamically to avoid a circular dependency
             const { detectProject } = await import('./detectors.js');
             const meta = await detectProject(workspaceRoot);
 

package/src/config/trusted-signing-keys.json

@@ -0,0 +1,3 @@
+[
+  { "keyId": "vh-2026-09", "publicKey": "MCowBQYDK2VwAyEAp1QFJcXW1Xgz+B0Qppsgqc87rZmwrggKYC3dh4n7aBg=" }
+]

package/src/detectors/build-tool-detector.js

@@ -0,0 +1,50 @@
+/**
+ * build-tool-detector.js — PASSO 0 of the fix validation ladder.
+ *
+ * Thin facade over the battle-tested detectProject() (src/detectors.js) that
+ * normalizes its output into the {stack, tier} shape the auto-fix engine
+ * consumes. One source of truth: marker priority, multi-language and the
+ * "Swift wins" product rule all live in detectProject — this file only maps.
+ *
+ * Tiers (validation ladder):
+ *   A = C1 structural + C2 syntax + C3 build    (maven/gradle/node)
+ *   B = C1 + C2, build unsupported on this host (xcode/swift — needs macOS)
+ *   C = C1 only                                 (anything unrecognized)
+ */
+import { detectProject } from '../detectors.js';
+
+const STACK_BY_BUILD_TOOL = {
+    maven: 'maven',
+    gradle: 'gradle',
+    npm: 'node',
+    yarn: 'node',
+    pnpm: 'node',
+    xcodebuild: 'xcode',
+    swiftpm: 'xcode',
+    cocoapods: 'xcode',
+    go: 'go',
+    pip: 'python',
+    poetry: 'python',
+    bundler: 'ruby',
+    rake: 'ruby',
+};
+
+const TIER_BY_STACK = {
+    maven: 'A',
+    gradle: 'A',
+    node: 'A',
+    xcode: 'B',
+};
+
+export async function detectBuildTool(workspacePath) {
+    const meta = await detectProject(workspacePath);
+    const buildTool = meta?.buildTool || 'unknown';
+    const stack = STACK_BY_BUILD_TOOL[buildTool] || 'unknown';
+    return {
+        stack,
+        tier: TIER_BY_STACK[stack] || 'C',
+        language: meta?.language || 'unknown',
+        buildTool,
+        marker: meta?.marker || null,
+    };
+}

package/src/detectors/multi-project-detector.js

@@ -9,24 +9,24 @@ import { FileReader } from "../workspace/file-reader.js";
 /**
  * MultiProjectDetector
  *
- * Detecta múltiplos projetos dentro de um workspace
- * Escaneia subpastas em busca de projetos independentes (pom.xml, package.json, etc)
+ * Detects multiple projects within a workspace
+ * Scans subfolders looking for independent projects (pom.xml, package.json, etc)
  */
 export class MultiProjectDetector {
     constructor(workspaceRoot) {
         this.workspaceRoot = workspaceRoot;
-        this.maxDepth = 2; // Escanear até 2 níveis de profundidade
+        this.maxDepth = 2; // Scan up to 2 levels deep
     }
 
     /**
-     * Detecta todos os projetos no workspace
+     * Detects all projects in the workspace
      */
     async detectProjects() {
         console.log(`🔍 Scanning workspace for multiple projects: ${this.workspaceRoot}`);
 
         const projects = [];
 
-        // 1️⃣ Verificar se o próprio workspace root é um projeto
+        // 1️⃣ Check whether the workspace root itself is a project
         if (await this.isProject(this.workspaceRoot)) {
             console.log(`✅ Root is a project`);
             projects.push({
@@ -36,13 +36,13 @@ export class MultiProjectDetector {
             });
         }
 
-        // 2️⃣ Escanear subpastas em busca de projetos
+        // 2️⃣ Scan subfolders looking for projects
         const subProjects = await this.scanSubdirectories(this.workspaceRoot, 0);
         projects.push(...subProjects);
 
         console.log(`✅ Found ${projects.length} project(s) in workspace`);
 
-        // 3️⃣ Detectar serviços para cada projeto
+        // 3️⃣ Detect services for each project
         const allServices = [];
         for (const project of projects) {
             console.log(`🔎 Detecting services in: ${project.name}`);
@@ -55,7 +55,7 @@ export class MultiProjectDetector {
     }
 
     /**
-     * Verifica se um diretório é um projeto
+     * Checks whether a directory is a project
      */
     async isProject(dir) {
         const markers = [
@@ -67,12 +67,12 @@ export class MultiProjectDetector {
             'pyproject.toml',    // Python Poetry
             'go.mod',            // Go
             'Cargo.toml',        // Rust
-            '.csproj',           // .NET (qualquer arquivo .csproj)
+            '.csproj',           // .NET (any .csproj file)
             '.sln'               // .NET solution
         ];
 
         for (const marker of markers) {
-            // Para .csproj e .sln, procurar qualquer arquivo com extensão
+            // For .csproj and .sln, look for any file with that extension
             if (marker.startsWith('.')) {
                 try {
                     const files = await readdir(dir);
@@ -83,7 +83,7 @@ export class MultiProjectDetector {
                     continue;
                 }
             } else {
-                // Para markers específicos, verificar se existe
+                // For specific markers, check whether they exist
                 if (await exists(path.join(dir, marker))) {
                     return true;
                 }
@@ -94,7 +94,7 @@ export class MultiProjectDetector {
     }
 
     /**
-     * Escaneia subdiretórios recursivamente
+     * Scans subdirectories recursively
      */
     async scanSubdirectories(dir, depth) {
         if (depth >= this.maxDepth) {
@@ -109,7 +109,7 @@ export class MultiProjectDetector {
             for (const entry of entries) {
                 if (!entry.isDirectory()) continue;
 
-                // Ignorar pastas comuns que não são projetos
+                // Ignore common folders that are not projects
                 const ignoreDirs = [
                     'node_modules', 'target', 'build', 'dist', 'out',
                     '.git', '.idea', '.vscode', '__pycache__',
@@ -123,7 +123,7 @@ export class MultiProjectDetector {
 
                 const fullPath = path.join(dir, entry.name);
 
-                // Verificar se é um projeto
+                // Check whether it is a project
                 if (await this.isProject(fullPath)) {
                     console.log(`✅ Found project: ${entry.name}`);
                     projects.push({
@@ -131,11 +131,11 @@ export class MultiProjectDetector {
                         path: fullPath,
                         isRoot: false
                     });
-                    // Não escanear dentro de projetos encontrados
+                    // Do not scan inside projects that were found
                     continue;
                 }
 
-                // Continuar escaneando recursivamente
+                // Keep scanning recursively
                 const subProjects = await this.scanSubdirectories(fullPath, depth + 1);
                 projects.push(...subProjects);
             }
@@ -147,19 +147,19 @@ export class MultiProjectDetector {
     }
 
     /**
-     * Detecta serviços em um projeto específico
+     * Detects services in a specific project
      */
     async detectServicesInProject(project) {
         try {
-            // Usar o scanner para analisar o projeto
+            // Use the scanner to analyze the project
             const scanner = new WorkspaceScanner(project.path);
             const structure = await scanner.scan();
 
-            // Detectar linguagem
+            // Detect the language
             const languageDetector = new LanguageDetector(structure.files);
             const languageInfo = languageDetector.detect();
 
-            // Detectar framework
+            // Detect the framework
             const fileReader = new FileReader(project.path);
             const frameworkDetector = new FrameworkDetector(
                 languageInfo.primary,
@@ -168,7 +168,7 @@ export class MultiProjectDetector {
             );
             const frameworkInfo = await frameworkDetector.detect();
 
-            // Detectar serviços
+            // Detect the services
             const serviceDetector = new ServiceDetector(
                 project.path,
                 languageInfo,
@@ -177,7 +177,7 @@ export class MultiProjectDetector {
 
             const services = await serviceDetector.detect();
 
-            // Adicionar nome do workspace a cada serviço
+            // Add the workspace name to each service
             return services.map(service => ({
                 ...service,
                 workspaceName: project.name,