thuban 0.3.2 → 0.3.3

package/packages/scanner/monitor-notifier.js

@@ -0,0 +1,64 @@
+const path = require('path');
+
+class MonitorNotifier {
+  constructor({ alertManager, store, repoConfig }) {
+    this.alertManager = alertManager;
+    this.store = store;
+    this.repoConfig = repoConfig;
+  }
+
+  async notify(diff, run) {
+    const channels = this.repoConfig.notification?.channels || ['inbox'];
+    const notifications = [];
+
+    if (!diff.hasNewIssues) {
+      return notifications;
+    }
+
+    const summary = `Found ${diff.added.length} new issue${diff.added.length === 1 ? '' : 's'} in ${this.repoConfig.repoPath}`;
+    const payload = {
+      timestamp: new Date().toISOString(),
+      repoId: this.repoConfig.repoId,
+      repoPath: this.repoConfig.repoPath,
+      channels,
+      summary,
+      newIssues: diff.added.slice(0, 10).map(issue => ({
+        file: issue.file,
+        line: issue.line,
+        severity: issue.severity,
+        category: issue.category,
+        message: issue.message,
+      })),
+      runTimestamp: run.timestamp,
+    };
+
+    if (channels.includes('inbox')) {
+      this.store.appendNotification(payload);
+      notifications.push({ channel: 'inbox', delivered: true });
+    }
+
+    if (channels.includes('console') && this.alertManager) {
+      await this.alertManager.sendAlert({
+        level: 'warning',
+        category: 'scheduled-scan',
+        title: 'Thuban monitor detected new issues',
+        message: summary,
+        file: path.join(this.repoConfig.repoPath, '.'),
+        details: payload,
+      });
+      notifications.push({ channel: 'console', delivered: true });
+    }
+
+    if (channels.includes('webhook')) {
+      notifications.push({ channel: 'webhook', delivered: false, stub: true });
+    }
+
+    if (channels.includes('email')) {
+      notifications.push({ channel: 'email', delivered: false, stub: true });
+    }
+
+    return notifications;
+  }
+}
+
+module.exports = MonitorNotifier;

package/packages/scanner/monitor-service.js

@@ -0,0 +1,103 @@
+const path = require('path');
+
+const AlertManager = require('./alert-manager.js');
+const MonitorStore = require('./monitor-store.js');
+const MonitorNotifier = require('./monitor-notifier.js');
+const { runScanPipeline } = require('./scan-runner.js');
+const { diffRuns } = require('./scan-diff.js');
+const { collectFiles } = require('./file-collector.js');
+
+function resolveIntervalMs(frequency, intervalMs) {
+  if (frequency === 'weekly') return 7 * 24 * 60 * 60 * 1000;
+  if (frequency === 'custom') return Math.max(60 * 1000, Number(intervalMs) || 24 * 60 * 60 * 1000);
+  return 24 * 60 * 60 * 1000;
+}
+
+class MonitorService {
+  constructor(options = {}) {
+    this.store = options.store || new MonitorStore();
+    this.timers = new Map();
+  }
+
+  configureRepo({ repoPath, frequency = 'daily', intervalMs, notification }) {
+    const repoId = this.store.getRepoId(repoPath);
+    const effectiveIntervalMs = resolveIntervalMs(frequency, intervalMs);
+    const repoConfig = this.store.upsertRepo({
+      repoId,
+      repoPath,
+      frequency,
+      intervalMs: effectiveIntervalMs,
+      notification,
+      nextRunAt: new Date(Date.now() + effectiveIntervalMs).toISOString(),
+    });
+    return repoConfig;
+  }
+
+  async runRepoScan(repoConfig) {
+    const rootPath = path.resolve(repoConfig.repoPath);
+    const files = this._collectFiles(rootPath);
+    const startedAt = Date.now();
+    const pipeline = await runScanPipeline({ rootPath, files });
+    const run = {
+      repoId: repoConfig.repoId,
+      repoPath: rootPath,
+      timestamp: new Date().toISOString(),
+      durationMs: Date.now() - startedAt,
+      frequency: repoConfig.frequency,
+      metrics: pipeline.metrics,
+      summary: pipeline.summary,
+      issues: pipeline.issues,
+    };
+
+    const previousRun = this.store.getLatestRun(repoConfig.repoId);
+    const diff = diffRuns(previousRun, run);
+    run.diff = diff;
+
+    const runPath = this.store.saveRun(repoConfig.repoId, run);
+    const updatedRepo = this.store.upsertRepo({
+      ...repoConfig,
+      lastRunAt: run.timestamp,
+      nextRunAt: new Date(Date.now() + repoConfig.intervalMs).toISOString(),
+    });
+
+    const notifier = new MonitorNotifier({
+      alertManager: new AlertManager({ rootPath, consoleOutput: true, fileOutput: true }),
+      store: this.store,
+      repoConfig: updatedRepo,
+    });
+    run.notifications = await notifier.notify(diff, run);
+
+    return { run, runPath, previousRun, diff };
+  }
+
+  start(repoConfig, { once = false } = {}) {
+    const execute = async () => {
+      try {
+        await this.runRepoScan(repoConfig);
+      } catch (error) {
+        console.error(`[THUBAN MONITOR] Scheduled scan failed for ${repoConfig.repoPath}: ${error.message}`);
+      }
+    };
+
+    execute();
+    if (once) return;
+
+    const timer = setInterval(execute, repoConfig.intervalMs);
+    this.timers.set(repoConfig.repoId, timer);
+    return timer;
+  }
+
+  stopAll() {
+    for (const timer of this.timers.values()) clearInterval(timer);
+    this.timers.clear();
+  }
+
+  _collectFiles(rootPath) {
+    return collectFiles(rootPath);
+  }
+}
+
+module.exports = {
+  MonitorService,
+  resolveIntervalMs,
+};

package/packages/scanner/monitor-store.js

@@ -0,0 +1,117 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const THUBAN_DIR = path.join(os.homedir(), '.thuban');
+const MONITOR_DIR = path.join(THUBAN_DIR, 'monitor');
+const CONFIG_FILE = path.join(MONITOR_DIR, 'config.json');
+const RUNS_DIR = path.join(MONITOR_DIR, 'runs');
+const NOTIFICATIONS_FILE = path.join(MONITOR_DIR, 'notifications.json');
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function safeReadJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (error) {
+    return fallback;
+  }
+}
+
+class MonitorStore {
+  constructor() {
+    ensureDir(THUBAN_DIR);
+    ensureDir(MONITOR_DIR);
+    ensureDir(RUNS_DIR);
+  }
+
+  getRepoId(repoPath) {
+    return crypto.createHash('sha256').update(path.resolve(repoPath)).digest('hex').substring(0, 12);
+  }
+
+  loadConfig() {
+    return safeReadJson(CONFIG_FILE, { version: 1, repos: [] });
+  }
+
+  saveConfig(config) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  }
+
+  upsertRepo(repoConfig) {
+    const config = this.loadConfig();
+    const repoId = repoConfig.repoId || this.getRepoId(repoConfig.repoPath);
+    const nextRepo = {
+      repoId,
+      repoPath: path.resolve(repoConfig.repoPath),
+      frequency: repoConfig.frequency || 'daily',
+      intervalMs: repoConfig.intervalMs,
+      notification: repoConfig.notification || { channels: ['inbox'] },
+      createdAt: repoConfig.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      enabled: repoConfig.enabled !== false,
+      lastRunAt: repoConfig.lastRunAt || null,
+      nextRunAt: repoConfig.nextRunAt || null,
+    };
+
+    const index = config.repos.findIndex(repo => repo.repoId === repoId);
+    if (index >= 0) config.repos[index] = { ...config.repos[index], ...nextRepo };
+    else config.repos.push(nextRepo);
+
+    this.saveConfig(config);
+    return nextRepo;
+  }
+
+  listRepos() {
+    return this.loadConfig().repos || [];
+  }
+
+  getRepo(repoIdOrPath) {
+    const resolved = repoIdOrPath ? path.resolve(repoIdOrPath) : null;
+    return this.listRepos().find(repo => repo.repoId === repoIdOrPath || repo.repoPath === resolved) || null;
+  }
+
+  getRepoRunDir(repoId) {
+    const dirPath = path.join(RUNS_DIR, repoId);
+    ensureDir(dirPath);
+    return dirPath;
+  }
+
+  saveRun(repoId, run) {
+    const runDir = this.getRepoRunDir(repoId);
+    const filePath = path.join(runDir, `${run.timestamp.replace(/[:.]/g, '-')}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(run, null, 2), 'utf-8');
+    return filePath;
+  }
+
+  listRuns(repoId) {
+    const runDir = this.getRepoRunDir(repoId);
+    return fs.readdirSync(runDir)
+      .filter(file => file.endsWith('.json'))
+      .sort()
+      .map(file => safeReadJson(path.join(runDir, file), null))
+      .filter(Boolean);
+  }
+
+  getLatestRun(repoId) {
+    const runs = this.listRuns(repoId);
+    return runs.length ? runs[runs.length - 1] : null;
+  }
+
+  appendNotification(notification) {
+    const payload = safeReadJson(NOTIFICATIONS_FILE, { notifications: [] });
+    payload.notifications.push(notification);
+    fs.writeFileSync(NOTIFICATIONS_FILE, JSON.stringify(payload, null, 2), 'utf-8');
+  }
+
+  getNotifications(limit = 20) {
+    const payload = safeReadJson(NOTIFICATIONS_FILE, { notifications: [] });
+    return payload.notifications.slice(-limit).reverse();
+  }
+}
+
+module.exports = MonitorStore;

package/packages/scanner/pre-commit-gate.js

@@ -29,7 +29,7 @@ class PreCommitGate {
         encoding: 'utf-8',
         timeout: 3000,
       });
-      const extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.mjs', '.cjs'];
+      const extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.mjs', '.cjs', '.php', '.rb'];
       return output
         .split('\n')
         .filter(f => f.trim() && extensions.some(ext => f.endsWith(ext)))

package/packages/scanner/scan-diff.js

@@ -0,0 +1,50 @@
+function toMap(issues = []) {
+  const map = new Map();
+  for (const issue of issues) {
+    map.set(issue.fingerprint, issue);
+  }
+  return map;
+}
+
+function diffRuns(previousRun, currentRun) {
+  const previousIssues = previousRun?.issues || [];
+  const currentIssues = currentRun?.issues || [];
+  const previousMap = toMap(previousIssues);
+  const currentMap = toMap(currentIssues);
+
+  const added = [];
+  const resolved = [];
+
+  for (const issue of currentIssues) {
+    if (!previousMap.has(issue.fingerprint)) added.push(issue);
+  }
+
+  for (const issue of previousIssues) {
+    if (!currentMap.has(issue.fingerprint)) resolved.push(issue);
+  }
+
+  const previousMetrics = previousRun?.metrics || {};
+  const currentMetrics = currentRun?.metrics || {};
+
+  return {
+    added,
+    resolved,
+    unchangedCount: currentIssues.length - added.length,
+    metricsDelta: {
+      issueCount: (currentMetrics.issueCount || 0) - (previousMetrics.issueCount || 0),
+      hallucinations: (currentMetrics.hallucinations || 0) - (previousMetrics.hallucinations || 0),
+      secrets: (currentMetrics.secrets || 0) - (previousMetrics.secrets || 0),
+      techDebtScore: currentMetrics.techDebtScore == null || previousMetrics.techDebtScore == null
+        ? null
+        : currentMetrics.techDebtScore - previousMetrics.techDebtScore,
+      techDebtHours: currentMetrics.techDebtHours == null || previousMetrics.techDebtHours == null
+        ? null
+        : currentMetrics.techDebtHours - previousMetrics.techDebtHours,
+    },
+    hasNewIssues: added.length > 0,
+  };
+}
+
+module.exports = {
+  diffRuns,
+};

package/packages/scanner/scan-runner.js

@@ -0,0 +1,172 @@
+const path = require('path');
+
+const CodeScanner = require('./code-scanner.js');
+const HallucinationDetector = require('./hallucination-detector.js');
+const SecretScanner = require('./secret-scanner.js');
+const DriftDetector = require('./drift-detector.js');
+const TechDebtAnalyzer = require('./tech-debt-analyzer.js');
+
+function normalizeIssue(rootPath, issue) {
+  const fileValue = issue.file || issue.path || '';
+  const relativeFile = path.isAbsolute(fileValue)
+    ? path.relative(rootPath, fileValue)
+    : fileValue;
+
+  return {
+    file: relativeFile,
+    line: issue.line || null,
+    severity: issue.severity || 'unknown',
+    category: issue.category || 'unknown',
+    id: issue.id || null,
+    message: issue.message || '',
+    suggestion: issue.suggestion || null,
+    fixable: issue.fixable !== false,
+  };
+}
+
+function fingerprintIssue(issue) {
+  return [
+    issue.file || '',
+    issue.category || '',
+    issue.id || '',
+    String(issue.line || ''),
+    (issue.message || '').substring(0, 160),
+  ].join('|');
+}
+
+function summarizeIssues(issues) {
+  const summary = {
+    total: issues.length,
+    bySeverity: {},
+    byCategory: {},
+  };
+
+  for (const issue of issues) {
+    summary.bySeverity[issue.severity] = (summary.bySeverity[issue.severity] || 0) + 1;
+    summary.byCategory[issue.category] = (summary.byCategory[issue.category] || 0) + 1;
+  }
+
+  return summary;
+}
+
+async function runScanPipeline({ rootPath, files, ignorePatterns = [] }) {
+  const scanner = new CodeScanner({
+    rootPath,
+    ignorePatterns: ['node_modules/**', '.git/**', 'dist/**', ...ignorePatterns],
+  });
+  const hallucinationDetector = new HallucinationDetector({ rootPath });
+  const secretScanner = new SecretScanner({ rootPath });
+  const driftDetector = new DriftDetector({ rootPath });
+  const techDebtAnalyzer = new TechDebtAnalyzer({ rootPath });
+
+  const [scanResults, hallResults, secretResults, driftResults, debtResults] = await Promise.all([
+    scanner.scanFiles(files),
+    hallucinationDetector.scan(files),
+    secretScanner.scanFiles(files),
+    driftDetector.detectAll ? driftDetector.detectAll() : Promise.resolve({ issues: [] }),
+    techDebtAnalyzer.analyze ? techDebtAnalyzer.analyze(files) : Promise.resolve(null),
+  ]);
+
+  const issues = [];
+
+  for (const [file, fileResults] of Object.entries(scanResults || {})) {
+    if (!fileResults || !fileResults.issues) continue;
+    for (const issue of fileResults.issues) {
+      issues.push(normalizeIssue(rootPath, { file, ...issue }));
+    }
+  }
+
+  for (const issue of secretResults?.issues || []) {
+    issues.push(normalizeIssue(rootPath, issue));
+  }
+
+  for (const issue of driftResults?.issues || []) {
+    issues.push(normalizeIssue(rootPath, issue));
+  }
+
+  for (const item of hallResults?.phantomAPIs || []) {
+    issues.push(normalizeIssue(rootPath, {
+      file: item.file,
+      line: item.line,
+      severity: 'critical',
+      category: 'hallucination',
+      id: item.id || 'HALL_API',
+      message: `${item.name} — this API does not exist`,
+      suggestion: item.suggestion,
+      fixable: false,
+    }));
+  }
+
+  for (const item of hallResults?.phantomImports || []) {
+    issues.push(normalizeIssue(rootPath, {
+      file: item.file,
+      line: item.line,
+      severity: 'critical',
+      category: 'hallucination',
+      id: item.id || 'HALL_IMPORT',
+      message: `${item.module} — ${item.reason}`,
+      suggestion: item.suggestion || null,
+      fixable: false,
+    }));
+  }
+
+  for (const item of hallResults?.deprecatedAPIs || []) {
+    issues.push(normalizeIssue(rootPath, {
+      file: item.file,
+      line: item.line,
+      severity: 'high',
+      category: 'deprecated',
+      id: item.id || 'DEPR_API',
+      message: `${item.name} — deprecated since ${item.since}`,
+      suggestion: item.suggestion,
+    }));
+  }
+
+  for (const item of hallResults?.aiSmells || []) {
+    issues.push(normalizeIssue(rootPath, {
+      file: item.file,
+      line: item.line,
+      severity: 'warning',
+      category: 'ai_smell',
+      id: item.id,
+      message: item.message,
+    }));
+  }
+
+  const uniqueIssues = [];
+  const seen = new Set();
+  for (const issue of issues) {
+    const fingerprint = fingerprintIssue(issue);
+    if (seen.has(fingerprint)) continue;
+    seen.add(fingerprint);
+    uniqueIssues.push({ ...issue, fingerprint });
+  }
+
+  const metrics = {
+    filesScanned: files.length,
+    issueCount: uniqueIssues.length,
+    hallucinations: uniqueIssues.filter(issue => issue.category === 'hallucination').length,
+    secrets: uniqueIssues.filter(issue => issue.category === 'secret' || String(issue.id || '').startsWith('SECRET')).length,
+    techDebtScore: debtResults?.summary?.score ?? debtResults?.score ?? null,
+    techDebtHours: debtResults?.summary?.estimatedHours ?? debtResults?.estimatedHours ?? null,
+  };
+
+  return {
+    issues: uniqueIssues,
+    summary: summarizeIssues(uniqueIssues),
+    metrics,
+    raw: {
+      scanResults,
+      hallResults,
+      secretResults,
+      driftResults,
+      debtResults,
+    },
+  };
+}
+
+module.exports = {
+  runScanPipeline,
+  fingerprintIssue,
+  summarizeIssues,
+};