deepdebug-local-agent 1.0.21 → 1.0.23

package/src/adapters/ibmmq/index.js

@@ -0,0 +1,137 @@
+// src/adapters/ibmmq/index.js
+// IbmMqLogAdapter — watches AMQERR0[1-3].LOG in the configured MQ errors dir;
+// emits 6-key error events. AD-1 lifecycle, AD-3 polling, AD-4 byte-position
+// dedup with TAIL-on-startup default, AD-5 per-file ordering.
+// T-2-01 mitigation: default polling interval 5000 ms.
+
+import { EventEmitter } from 'node:events';
+import { stat, open } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import chokidar from 'chokidar';
+import { extractAmqCode } from './ibmmq-parser.js';
+
+const ADAPTER = 'ibmmq';
+
+// T-2-03 anchor: only AMQERR01.LOG / AMQERR02.LOG / AMQERR03.LOG are accepted.
+// Equivalent to the glob AMQERR0[1-3].LOG, but enforced post-watch in the handler
+// because chokidar usePolling:true does not engage with bracket-class globs on
+// macOS/Node 24 (verified empirically: AMQERR*.LOG fires events; AMQERR0[1-3].LOG
+// fires nothing). The watcher uses AMQERR*.LOG; this regex narrows back to 01..03.
+const IBMMQ_FILENAME_ANCHOR = /^AMQERR0[1-3]\.LOG$/;
+
+export class IbmMqLogAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.errorsDir = config.errorsDir || '/var/mqm/qmgrs/QM_PRD01/errors';
+    this.interval = config.interval ?? 5000;
+    this.replayOnStart = config.replayOnStart === true;
+    this._watcher = null;
+    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;
+
+    // Watch glob = AMQERR*.LOG (chokidar polling-compatible); the strict anchor
+    // AMQERR0[1-3].LOG is enforced by IBMMQ_FILENAME_ANCHOR on every event.
+    const glob = join(this.errorsDir, 'AMQERR*.LOG');
+
+    this._watcher = chokidar.watch(glob, {
+      usePolling: true,
+      interval: this.interval,
+      ignoreInitial: false, // we handle initial ourselves via TAIL seek
+      awaitWriteFinish: false,
+    });
+
+    const isAnchoredFile = (fp) => IBMMQ_FILENAME_ANCHOR.test(basename(fp));
+
+    const onAdd = async (filePath) => {
+      if (!isAnchoredFile(filePath)) return; // T-2-03: drop non-anchored
+      if (this.replayOnStart) {
+        this._offsets.set(filePath, 0);
+        // fall through to _readNew below
+      } 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; }
+      }
+      this._readNew(filePath).catch(() => { /* ENOENT silence */ });
+    };
+
+    this._watcher.on('add', onAdd);
+    this._watcher.on('change', (fp) => {
+      if (!isAnchoredFile(fp)) return; // T-2-03: drop non-anchored
+      this._readNew(fp).catch(() => { /* ENOENT silence */ });
+    });
+
+    // Swallow chokidar's own bubbled errors (e.g., watch-path ENOENT).
+    this._watcher.on('error', () => {});
+  }
+
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    if (this._watcher) {
+      await this._watcher.close().catch(() => {});
+      this._watcher = null;
+    }
+    this._offsets.clear();
+    this._inodes.clear();
+  }
+
+  async _readNew(filePath) {
+    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); // 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);
+      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;
+        const code = extractAmqCode(line);
+        if (!code) continue;
+        // 6-key frozen event payload (AD-4 contract — extra keys forbidden)
+        const event = Object.freeze({
+          adapter: ADAPTER,
+          errorCode: code,
+          file: filePath,
+          message: line,
+          source: sourceDir,
+          timestamp: new Date().toISOString(),
+        });
+        this.emit('error', event);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+}
+
+export default IbmMqLogAdapter;

package/src/adapters/index.js

@@ -0,0 +1,79 @@
+// src/adapters/index.js
+// Phase 2 — Legacy connectors registry. AD-1: returns unstarted instances; caller starts.
+//
+// Public API:
+//   loadAdapters(config)           → unstarted Adapter[]
+//   stopAll(adapters, timeoutMs?)  → Promise<void>, never throws
+//   ALLOWED_STACK_LIST             → frozen string[] of valid stack names
+
+import { SapLogAdapter } from './sap/index.js';
+import { IbmMqLogAdapter } from './ibmmq/index.js';
+import { As400LogAdapter } from './as400/index.js';
+import { OracleFormsLogAdapter } from './oracle-forms/index.js';
+import { CobolLogAdapter } from './cobol/index.js';
+
+const ALLOWED_STACKS = Object.freeze(['sap', 'ibmmq', 'as400', 'oracle-forms', 'cobol']);
+
+const FACTORIES = Object.freeze({
+  'sap': (cfg) => new SapLogAdapter(cfg),
+  'ibmmq': (cfg) => new IbmMqLogAdapter(cfg),
+  'as400': (cfg) => new As400LogAdapter(cfg),
+  'oracle-forms': (cfg) => new OracleFormsLogAdapter(cfg),
+  'cobol': (cfg) => new CobolLogAdapter(cfg),
+});
+
+/**
+ * Load configured adapter instances WITHOUT starting them (AD-1).
+ *
+ * @param {object} config
+ * @param {string[]} config.legacyStacks subset of ['sap','ibmmq','as400','oracle-forms','cobol']
+ * @param {object} [config.sap]          per-adapter config object
+ * @param {object} [config.ibmmq]
+ * @param {object} [config.as400]
+ * @param {object} [config['oracle-forms']]
+ * @param {object} [config.cobol]
+ * @returns {Array} unstarted adapters; caller invokes .start() on each
+ * @throws {Error} on unknown stack name (message names the offender)
+ */
+export function loadAdapters(config = {}) {
+  const stacks = Array.isArray(config.legacyStacks) ? config.legacyStacks : [];
+  for (const s of stacks) {
+    if (!ALLOWED_STACKS.includes(s)) {
+      throw new Error(`loadAdapters: unknown stack '${s}'. Allowed: ${ALLOWED_STACKS.join(', ')}`);
+    }
+  }
+  return stacks.map((s) => FACTORIES[s](config[s] || {}));
+}
+
+/**
+ * Stop all adapters in parallel with overall timeout (AC-11).
+ * Used by SIGTERM handler. Never throws — failures are swallowed so the
+ * shutdown path always returns and the event loop drains.
+ *
+ * @param {Array} adapters
+ * @param {number} [timeoutMs=5000]
+ * @returns {Promise<void>}
+ */
+export async function stopAll(adapters, timeoutMs = 5000) {
+  if (!Array.isArray(adapters) || adapters.length === 0) return;
+  const stopPromises = adapters.map((a) =>
+    Promise.resolve()
+      .then(() => (typeof a?.stop === 'function' ? a.stop() : undefined))
+      .catch(() => { /* swallow per never-throw contract */ })
+  );
+  // Bounded timer so a non-resolving stop() cannot block process exit.
+  let timer;
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(resolve, timeoutMs);
+    // Per project convention, unref the timer so it never holds the loop open
+    // beyond the rest of the work (AD-3 timer hygiene).
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+  try {
+    await Promise.race([Promise.all(stopPromises), timeoutPromise]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+export const ALLOWED_STACK_LIST = ALLOWED_STACKS;

package/src/adapters/oracle-forms/index.js

@@ -0,0 +1,145 @@
+// src/adapters/oracle-forms/index.js
+// OracleFormsLogAdapter — watches *.trc files in the configured Forms trace
+// dir; emits 6-key error events. AD-1 lifecycle, AD-3 polling, AD-4 byte-position
+// dedup with TAIL-on-startup default, AD-5 per-file ordering, AD-6 Latin-1
+// mojibake-trap tolerance via latin1 decode (never throws on any byte).
+// T-2-01 mitigation: default polling interval 5000 ms.
+
+import { EventEmitter } from 'node:events';
+import { stat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { extractFormsCode } from './oracle-forms-parser.js';
+
+const ADAPTER = 'oracle-forms';
+
+// Decode buffer using Latin-1 (single-byte) encoding — never throws on any
+// byte sequence. ORA/FRM message codes are ASCII so the regex match is
+// unaffected by the choice; accented free-text payload bytes survive into
+// `message` as Latin-1 characters (mojibake-tolerant per AD-6 Forms trap).
+function decodeTolerant(buf) {
+  return buf.toString('latin1');
+}
+
+export class OracleFormsLogAdapter extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.traceDir = config.traceDir || '/u01/oracle/forms/trace';
+    this.interval = config.interval ?? 5000;
+    this.replayOnStart = config.replayOnStart === true;
+    this._watcher = null;
+    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;
+
+    // Glob bound to *.trc only (wildcard — chokidar polling-mode bracket-class
+    // workaround from Plan 02-08 does NOT apply here; *.trc is a plain wildcard).
+    const glob = join(this.traceDir, '*.trc');
+
+    this._watcher = chokidar.watch(glob, {
+      usePolling: true,
+      interval: this.interval,
+      ignoreInitial: false, // we handle initial ourselves via TAIL seek
+      awaitWriteFinish: false,
+    });
+
+    const onAdd = async (filePath) => {
+      if (this.replayOnStart) {
+        this._offsets.set(filePath, 0);
+        // fall through to _readNew below
+      } 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;
+        }
+      }
+      this._readNew(filePath).catch(() => { /* ENOENT silence */ });
+    };
+
+    this._watcher.on('add', onAdd);
+    this._watcher.on('change', (fp) => {
+      this._readNew(fp).catch(() => { /* ENOENT silence */ });
+    });
+
+    // Swallow chokidar's own bubbled errors (e.g., watch-path ENOENT) —
+    // dual-layer suppression with the per-read try/catch ensures full
+    // ENOENT silence (canonical pattern from Plan 02-07).
+    this._watcher.on('error', () => {});
+  }
+
+  async stop() {
+    if (!this._isRunning) return;
+    this._isRunning = false;
+    if (this._watcher) {
+      await this._watcher.close().catch(() => {});
+      this._watcher = null;
+    }
+    this._offsets.clear();
+    this._inodes.clear();
+  }
+
+  async _readNew(filePath) {
+    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); // 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);
+      const text = decodeTolerant(buf);
+      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;
+        const code = extractFormsCode(line);
+        if (!code) continue;
+        // 6-key frozen event payload (AD-4 contract — extra keys forbidden)
+        const event = Object.freeze({
+          adapter: ADAPTER,
+          errorCode: code,
+          file: filePath,
+          message: line,
+          source: sourceDir,
+          timestamp: new Date().toISOString(),
+        });
+        this.emit('error', event);
+      }
+    } finally {
+      await fh.close();
+    }
+  }
+}
+
+export default OracleFormsLogAdapter;

package/src/adapters/oracle-forms/oracle-forms-parser.js

@@ -0,0 +1,11 @@
+// src/adapters/oracle-forms/oracle-forms-parser.js
+// T-2-03 isolation surface: regex exported as a named const so it can be
+// unit-tested against arbitrary text decoupled from the file-watching
+// machinery in index.js. The watcher itself is bound to a literal *.trc
+// glob so this regex never engages arbitrary text by construction.
+export const ORACLE_FORMS_REGEX = /(?:Line \d+:|^)\s*(ORA-\d{5}|FRM-\d{5}):\s*(.+)/;
+
+export function extractFormsCode(line) {
+  const m = line.match(ORACLE_FORMS_REGEX);
+  return m ? m[1] : null;
+}

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/detectors/framework-detector.js

@@ -17,11 +17,44 @@ export class FrameworkDetector {
                 return { framework: 'dotnet', version: null, buildTool: 'dotnet' };
             case 'go':
                 return { framework: 'go', version: null, buildTool: 'go' };
+            case 'ios':
+                return this.detectSwiftFramework();
+            case 'kotlin':
+                return this.detectKotlinFramework();
             default:
                 return { framework: 'unknown', version: null, buildTool: null };
         }
     }
 
+    async detectSwiftFramework() {
+        for (const f of this.files) {
+            if (!f.name.endsWith('.swift')) continue;
+            try {
+                const c = await this.fileReader.read(f.path);
+                if (c.content && c.content.includes('import SwiftUI')) {
+                    return { framework: 'swiftui', version: null, buildTool: 'xcodebuild' };
+                }
+                if (c.content && c.content.includes('import UIKit')) {
+                    return { framework: 'uikit', version: null, buildTool: 'xcodebuild' };
+                }
+            } catch (_) {}
+        }
+        return { framework: 'swift-plain', version: null, buildTool: 'xcodebuild' };
+    }
+
+    async detectKotlinFramework() {
+        for (const f of this.files) {
+            if (!f.name.endsWith('.kt')) continue;
+            try {
+                const c = await this.fileReader.read(f.path);
+                if (c.content && c.content.includes('androidx.compose')) {
+                    return { framework: 'jetpack-compose', version: null, buildTool: 'gradle' };
+                }
+            } catch (_) {}
+        }
+        return { framework: 'android-xml', version: null, buildTool: 'gradle' };
+    }
+
     async detectJavaFramework() {
         const pomFile = this.files.find(f => f.name === 'pom.xml');
         if (pomFile) {

package/src/detectors/language-detector.js

@@ -16,6 +16,15 @@ export class LanguageDetector {
 
     findMarkers() {
         const markers = {
+            // iOS/Swift (highest priority when BOTH iOS and Java exist, per product rule:
+            // "Swift wins — it means the dev copied iOS files into a Java repo").
+            ios: this.files.some(f =>
+                f.name === 'Package.swift' ||
+                f.name === 'Podfile' ||
+                f.name === 'Podfile.lock' ||
+                f.name === 'Cartfile' ||
+                (f.name && (f.name.endsWith('.xcodeproj') || f.name.endsWith('.xcworkspace')))
+            ),
             java: this.files.some(f => f.name === 'pom.xml' || f.name === 'build.gradle'),
             kotlin: this.files.some(f => f.name === 'build.gradle.kts'),
             node: this.files.some(f => f.name === 'package.json'),
@@ -47,6 +56,20 @@ export class LanguageDetector {
             .filter(([_, exists]) => exists)
             .map(([lang]) => lang);
 
+        // Priority rule: iOS wins over anything else when its strong markers are present.
+        // Rationale: if a repo has BOTH Package.swift/Podfile/xcodeproj AND pom.xml, the
+        // developer copied iOS files into a Java repo (or vice versa) - the iOS app is
+        // the shipping artifact.
+        if (markers.ios) return 'ios';
+        // Even without strong iOS markers, a repo dominated by .swift source files is iOS.
+        const swiftCount = extensions['.swift'] || 0;
+        const totalCode = Object.entries(extensions)
+                .filter(([k]) => ['.swift','.m','.mm','.h','.java','.kt','.js','.ts','.py','.go','.rb','.cs','.php'].includes(k))
+                .reduce((s, [,v]) => s + v, 0);
+        if (swiftCount > 0 && (totalCode === swiftCount || swiftCount / Math.max(totalCode,1) >= 0.5)) {
+            return 'ios';
+        }
+
         if (detected.length === 1) return detected[0];
         if (detected.length > 1) {
             // Filter out meta-markers (docker, static) if real languages exist
@@ -83,7 +106,9 @@ export class LanguageDetector {
             '.dart': 'dart',
             '.ex': 'elixir',
             '.exs': 'elixir',
-            '.swift': 'swift',
+            '.swift': 'ios',
+            '.m': 'ios',
+            '.mm': 'ios',
             '.scala': 'scala',
         };
         return map[ext] || null;