thuban 0.3.3 → 0.4.0

package/packages/scanner/file-collector.js

@@ -1,64 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-function collectFiles(dir, ignorePatterns = []) {
-  const defaultIgnore = ['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.venv', 'venv', 'coverage', '.cache', '.turbo'];
-  const allIgnore = [...defaultIgnore, ...ignorePatterns];
-  const extensions = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.py', '.pyw', '.go', '.rs', '.java', '.kt', '.cs', '.php', '.rb', '.json'];
-  const maxFileSize = 1024 * 1024;
-  const maxFiles = 50000;
-  const files = [];
-  const visitedPaths = new Set(); // Track real paths to handle symlinks
-
-  function walk(currentDir) {
-    if (files.length >= maxFiles) return;
-    let entries;
-    try {
-      entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    } catch (error) {
-      return;
-    }
-
-    for (const entry of entries) {
-      if (files.length >= maxFiles) return;
-      if (allIgnore.some(pattern => entry.name === pattern || entry.name.match(pattern))) continue;
-      const fullPath = path.join(currentDir, entry.name);
-
-      // Handle symlinks — resolve and skip if already visited or points outside
-      if (entry.isSymbolicLink()) {
-        try {
-          const realPath = fs.realpathSync(fullPath);
-          if (visitedPaths.has(realPath)) continue;
-          visitedPaths.add(realPath);
-          const stat = fs.statSync(fullPath); // follow symlink
-          if (stat.isDirectory()) {
-            walk(fullPath);
-          } else if (stat.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
-            if (stat.size > 0 && stat.size <= maxFileSize) files.push(fullPath);
-          }
-        } catch {
-          continue; // Broken symlink — skip
-        }
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        walk(fullPath);
-      } else if (entry.isFile() && extensions.some(ext => entry.name.endsWith(ext))) {
-        try {
-          const stat = fs.statSync(fullPath);
-          if (stat.size > 0 && stat.size <= maxFileSize) files.push(fullPath);
-        } catch (error) {
-          // Skip files we can't stat
-        }
-      }
-    }
-  }
-
-  walk(dir);
-  return files;
-}
-
-module.exports = {
-  collectFiles,
-};

package/packages/scanner/file-watcher.js

@@ -1,323 +0,0 @@
-/**
- * File Watcher
- *
- * @purpose Event-driven FileWatcher component
- * @module sentinel
- * @layer application
- * @imports-from fs, path, events
- * @exports-to sentinel
- * @side-effects File system reads, Console output, Event emission
- * @critical-for sentinel
- */
-
-/**
- * Sentinel File Watcher
- *
- * Real-time file system monitoring for the Orion codebase.
- * Detects file changes, additions, and deletions to trigger scans.
- */
-
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-class FileWatcher extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      rootPath: config.rootPath || process.cwd(),
-      watchPatterns: config.watchPatterns || ['**/*.js', '**/*.ts', '**/*.json'],
-      ignorePatterns: config.ignorePatterns || [
-        'node_modules/**',
-        '.git/**',
-        'dist/**',
-        'build/**',
-        '.orion/snapshots/**',
-        'coverage/**',
-        '*.log'
-      ],
-      debounceMs: config.debounceMs || 300,
-      ...config
-    };
-
-    this.watchers = [];
-    this.watchedFiles = new Set();
-    this.debounceTimers = new Map();
-    this.isRunning = false;
-  }
-
-  /**
-   * Start watching files
-   */
-  async start() {
-    if (this.isRunning) {
-      return { success: true, message: 'Already watching' };
-    }
-
-    console.log('[FILE-WATCHER] Starting file watcher...');
-    console.log(`[FILE-WATCHER] Root path: ${this.config.rootPath}`);
-
-    try {
-      // Discover files to watch
-      await this._discoverFiles(this.config.rootPath);
-
-      // Set up watchers
-      this._setupWatchers();
-
-      this.isRunning = true;
-      console.log(`[FILE-WATCHER] Watching ${this.watchedFiles.size} files`);
-
-      return {
-        success: true,
-        filesWatched: this.watchedFiles.size
-      };
-    } catch (error) {
-      console.error('[FILE-WATCHER] Start failed:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Stop watching files
-   */
-  async stop() {
-    console.log('[FILE-WATCHER] Stopping file watcher...');
-
-    // Close all watchers
-    for (const watcher of this.watchers) {
-      try {
-        watcher.close();
-      } catch (e) {
-        // Ignore close errors
-      }
-    }
-
-    // Clear debounce timers
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-
-    this.watchers = [];
-    this.debounceTimers.clear();
-    this.isRunning = false;
-
-    console.log('[FILE-WATCHER] Stopped');
-    return { success: true };
-  }
-
-  /**
-   * Get count of watched files
-   */
-  getWatchedCount() {
-    return this.watchedFiles.size;
-  }
-
-  /**
-   * Get list of watched files
-   */
-  getWatchedFiles() {
-    return Array.from(this.watchedFiles);
-  }
-
-  /**
-   * Check if a file path should be ignored
-   */
-  shouldIgnore(filePath) {
-    const relativePath = path.relative(this.config.rootPath, filePath);
-
-    for (const pattern of this.config.ignorePatterns) {
-      if (this._matchPattern(relativePath, pattern)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if a file path matches watch patterns
-   */
-  shouldWatch(filePath) {
-    const relativePath = path.relative(this.config.rootPath, filePath);
-
-    // First check if ignored
-    if (this.shouldIgnore(filePath)) {
-      return false;
-    }
-
-    // Then check if matches watch patterns
-    for (const pattern of this.config.watchPatterns) {
-      if (this._matchPattern(relativePath, pattern)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  // Private methods
-
-  async _discoverFiles(dir) {
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Skip ignored directories early
-        if (entry.isDirectory()) {
-          if (!this.shouldIgnore(fullPath)) {
-            await this._discoverFiles(fullPath);
-          }
-        } else if (entry.isFile()) {
-          if (this.shouldWatch(fullPath)) {
-            this.watchedFiles.add(fullPath);
-          }
-        }
-      }
-    } catch (error) {
-      // Directory might not exist or be inaccessible
-      if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-        console.warn(`[FILE-WATCHER] Error scanning ${dir}:`, error.message);
-      }
-    }
-  }
-
-  _setupWatchers() {
-    // Group files by directory for efficient watching
-    const directories = new Set();
-    for (const file of this.watchedFiles) {
-      directories.add(path.dirname(file));
-    }
-
-    // Watch each directory
-    for (const dir of directories) {
-      try {
-        const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
-          if (filename) {
-            const fullPath = path.join(dir, filename);
-            this._handleFileEvent(eventType, fullPath);
-          }
-        });
-
-        watcher.on('error', (error) => {
-          console.warn(`[FILE-WATCHER] Watcher error for ${dir}:`, error.message);
-        });
-
-        this.watchers.push(watcher);
-      } catch (error) {
-        console.warn(`[FILE-WATCHER] Could not watch ${dir}:`, error.message);
-      }
-    }
-
-    // Also set up a recursive watcher for the root (if supported)
-    try {
-      const rootWatcher = fs.watch(this.config.rootPath, { recursive: true }, (eventType, filename) => {
-        if (filename) {
-          const fullPath = path.join(this.config.rootPath, filename);
-          this._handleFileEvent(eventType, fullPath);
-        }
-      });
-
-      rootWatcher.on('error', (error) => {
-        // Recursive watch might not be supported on all platforms
-        if (error.code !== 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM') {
-          console.warn('[FILE-WATCHER] Root watcher error:', error.message);
-        }
-      });
-
-      this.watchers.push(rootWatcher);
-    } catch (error) {
-      // Recursive watching might not be available
-    }
-  }
-
-  _handleFileEvent(eventType, filePath) {
-    // Skip if ignored
-    if (this.shouldIgnore(filePath)) {
-      return;
-    }
-
-    // Debounce rapid events
-    if (this.debounceTimers.has(filePath)) {
-      clearTimeout(this.debounceTimers.get(filePath));
-    }
-
-    this.debounceTimers.set(filePath, setTimeout(() => {
-      this.debounceTimers.delete(filePath);
-      this._processFileEvent(eventType, filePath);
-    }, this.config.debounceMs));
-  }
-
-  _processFileEvent(eventType, filePath) {
-    // Check if file exists
-    const exists = fs.existsSync(filePath);
-    const isFile = exists && fs.statSync(filePath).isFile();
-
-    let event;
-
-    if (!exists) {
-      // File was deleted
-      if (this.watchedFiles.has(filePath)) {
-        this.watchedFiles.delete(filePath);
-        event = {
-          type: 'delete',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      }
-    } else if (isFile && this.shouldWatch(filePath)) {
-      if (this.watchedFiles.has(filePath)) {
-        // File was modified
-        event = {
-          type: 'change',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      } else {
-        // New file added
-        this.watchedFiles.add(filePath);
-        event = {
-          type: 'add',
-          filePath,
-          timestamp: new Date().toISOString()
-        };
-      }
-    }
-
-    if (event) {
-      this.emit(event.type, event);
-      this.emit('any', event);
-    }
-  }
-
-  _matchPattern(filePath, pattern) {
-    // Simple glob-like pattern matching
-    // Supports: *, **, ?
-
-    // Normalize separators
-    const normalizedPath = filePath.replace(/\\/g, '/');
-    const normalizedPattern = pattern.replace(/\\/g, '/');
-
-    // Convert glob pattern to regex
-    let regexPattern = normalizedPattern
-      .replace(/\./g, '\\.')           // Escape dots
-      .replace(/\*\*/g, '<<<GLOBSTAR>>>')  // Temporarily replace **
-      .replace(/\*/g, '[^/]*')         // * matches anything except /
-      .replace(/<<<GLOBSTAR>>>/g, '.*') // ** matches anything including /
-      .replace(/\?/g, '.');            // ? matches single char
-
-    // Anchor the pattern
-    regexPattern = '^' + regexPattern + '$';
-
-    try {
-      const regex = new RegExp(regexPattern);
-      return regex.test(normalizedPath);
-    } catch (e) {
-      return false;
-    }
-  }
-}
-
-module.exports = FileWatcher;

package/packages/scanner/ghost-code-detector.js

@@ -1,301 +0,0 @@
-/**
- * Thuban Ghost Code Detector
- *
- * @purpose Find AI-generated functions that were pasted but never called
- * @module thuban
- * @layer scanner
- * @exports-to cli
- * @critical-for Unique feature — no other tool targets "pasted but unwired" code
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class GhostCodeDetector {
-  constructor(opts = {}) {
-    this.rootPath = opts.rootPath || process.cwd();
-  }
-
-  /**
-   * Scan files for ghost (uncalled) functions
-   */
-  scan(files) {
-    const functions = [];   // All function definitions
-    const references = {};  // Function name → reference count
-
-    // Pass 1: Find all function definitions
-    for (const file of files) {
-      let content;
-      try {
-        const stat = fs.statSync(file);
-        if (stat.size > 512 * 1024) continue;
-        content = fs.readFileSync(file, 'utf-8');
-      } catch (e) {
-        continue;
-      }
-
-      const relPath = path.relative(this.rootPath, file);
-
-      // Skip test files, config files, and entry points
-      if (this._isSkippable(relPath)) continue;
-
-      const lines = content.split('\n');
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const fn = this._extractFunction(line, i, lines);
-        if (fn) {
-          fn.file = relPath;
-          fn.line = i + 1;
-          fn.lineCount = this._countFunctionLines(lines, i);
-          functions.push(fn);
-
-          // Initialize reference counter
-          if (!references[fn.name]) references[fn.name] = 0;
-        }
-      }
-    }
-
-    // Pass 2: Count references to each function
-    for (const file of files) {
-      let content;
-      try {
-        content = fs.readFileSync(file, 'utf-8');
-      } catch (e) {
-        continue;
-      }
-
-      // Strip comments and strings before counting references to avoid false negatives
-      // from functions that appear only in commented-out code
-      const strippedContent = this._stripCommentsAndStrings(content);
-
-      for (const fn of functions) {
-        if (fn.name.length < 3) continue; // Skip very short names (likely false positives)
-
-        // Count how many times this function name appears (excluding its definition)
-        const regex = new RegExp(`\\b${this._escapeRegex(fn.name)}\\b`, 'g');
-        const matches = strippedContent.match(regex);
-        if (matches) {
-          const relPath = path.relative(this.rootPath, file);
-          // Subtract 1 if this is the file where it's defined (the definition itself)
-          const isDefFile = relPath === fn.file;
-          references[fn.name] += matches.length - (isDefFile ? 1 : 0);
-        }
-      }
-    }
-
-    // Pass 3: Find ghosts — defined but never referenced elsewhere
-    const ghosts = functions
-      .filter(fn => {
-        const refs = references[fn.name] || 0;
-        // It's a ghost if:
-        // - Referenced 0 times outside its definition
-        // - Not an export (exports are meant to be used externally)
-        // - Not a constructor, lifecycle method, or callback pattern
-        return refs <= 0 && !fn.isExport && !fn.isLifecycle && fn.lineCount >= 5;
-      })
-      .map(fn => ({
-        ...fn,
-        references: references[fn.name] || 0,
-        wastedLines: fn.lineCount,
-        category: 'ghost',
-        severity: fn.lineCount > 30 ? 'high' : 'medium',
-        message: `${fn.name}() — ${fn.lineCount} lines, never called`,
-      }))
-      .sort((a, b) => b.wastedLines - a.wastedLines);
-
-    const totalWastedLines = ghosts.reduce((sum, g) => sum + g.wastedLines, 0);
-    const totalLines = files.reduce((sum, f) => {
-      try { return sum + fs.readFileSync(f, 'utf-8').split('\n').length; } catch (e) { return sum; }
-    }, 0);
-
-    return {
-      ghosts,
-      totalGhosts: ghosts.length,
-      totalWastedLines,
-      wastedPercent: totalLines > 0 ? Math.round((totalWastedLines / totalLines) * 1000) / 10 : 0,
-      totalLines,
-    };
-  }
-
-  // ─── Private ─────────────────────────────────────────────
-
-  _extractFunction(line, lineIndex, lines) {
-    const trimmed = line.trim();
-
-    // JavaScript/TypeScript: function name(
-    let match = trimmed.match(/^(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'function',
-        isExport: this._isExported(line, lineIndex, lines),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // JavaScript/TypeScript: const name = (async) function
-    match = trimmed.match(/^(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?function/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'const-function',
-        isExport: this._isExported(line, lineIndex, lines),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // JavaScript/TypeScript: const name = (...) =>
-    match = trimmed.match(/^(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?\(?/);
-    if (match && (trimmed.includes('=>') || (lineIndex + 1 < lines.length && lines[lineIndex + 1].includes('=>')))) {
-      return {
-        name: match[1],
-        type: 'arrow',
-        isExport: this._isExported(line, lineIndex, lines),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // Kotlin: fun functionName(
-    match = trimmed.match(/^(?:private\s+|public\s+|internal\s+|protected\s+)?(?:suspend\s+)?fun\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[(<]/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'kotlin-fun',
-        isExport: !trimmed.startsWith('private'),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // Rust: fn function_name(
-    match = trimmed.match(/^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[(<]/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'rust-fn',
-        isExport: /^pub/.test(trimmed),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // PHP: function functionName( or public/private/protected function functionName(
-    match = trimmed.match(/^(?:(?:public|private|protected|static)\s+)*function\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'php-function',
-        isExport: !/private/.test(trimmed),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // Ruby: def method_name or def self.method_name
-    match = trimmed.match(/^def\s+(?:self\.)?([a-zA-Z_][a-zA-Z0-9_?!]*)\s*[(\s]?/);
-    if (match) {
-      return {
-        name: match[1],
-        type: 'ruby-def',
-        isExport: !match[1].startsWith('_'),
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    // Class method: name(
-    match = trimmed.match(/^(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*{/);
-    if (match && !['if', 'for', 'while', 'switch', 'catch', 'constructor', 'render', 'toString'].includes(match[1])) {
-      return {
-        name: match[1],
-        type: 'method',
-        isExport: false,
-        isLifecycle: this._isLifecycle(match[1]),
-      };
-    }
-
-    return null;
-  }
-
-  _isExported(line, lineIndex, lines) {
-    if (/^export\s/.test(line.trim())) return true;
-    if (/module\.exports/.test(line)) return true;
-
-    // Check if it's exported later in the file
-    // (simplified — check last 20 lines for module.exports containing the function name)
-    return false;
-  }
-
-  _isLifecycle(name) {
-    const lifecycle = [
-      // JS/TS lifecycle
-      'constructor', 'render', 'componentDidMount', 'componentWillUnmount',
-      'componentDidUpdate', 'shouldComponentUpdate', 'getSnapshotBeforeUpdate',
-      'getDerivedStateFromProps', 'useEffect', 'useState', 'useMemo',
-      'toString', 'valueOf', 'toJSON', 'inspect',
-      'setup', 'teardown', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll',
-      'init', 'destroy', 'configure', 'bootstrap', 'main',
-      'get', 'set', 'post', 'put', 'delete', 'patch', 'handle',
-      // Kotlin/Java lifecycle
-      'onCreate', 'onStart', 'onResume', 'onPause', 'onStop', 'onDestroy',
-      'onCreateView', 'onViewCreated', 'onDestroyView', 'hashCode', 'equals',
-      // Rust lifecycle / trait methods
-      'new', 'default', 'drop', 'fmt', 'from', 'into', 'clone', 'copy',
-      // Ruby lifecycle
-      'initialize', 'to_s', 'to_str', 'inspect', 'freeze', 'dup',
-      // PHP lifecycle
-      '__construct', '__destruct', '__toString', '__get', '__set', '__call',
-    ];
-    return lifecycle.includes(name) || name.startsWith('_') || name.startsWith('on');
-  }
-
-  _countFunctionLines(lines, startLine) {
-    let depth = 0;
-    let started = false;
-    let count = 0;
-
-    for (let i = startLine; i < lines.length && i < startLine + 200; i++) {
-      const line = lines[i];
-      count++;
-
-      for (const ch of line) {
-        if (ch === '{') { depth++; started = true; }
-        if (ch === '}') depth--;
-      }
-
-      if (started && depth <= 0) break;
-    }
-
-    return count;
-  }
-
-  _isSkippable(relPath) {
-    const skip = [
-      /\.test\./i, /\.spec\./i, /test[\/\\]/i, /spec[\/\\]/i,
-      /__test__/i, /__mocks__/i, /\.config\./i, /\.d\.ts$/,
-      /index\.(js|ts)$/, /server\.(js|ts)$/, /app\.(js|ts)$/,
-      /routes?\.(js|ts)$/, /middleware/i,
-    ];
-    return skip.some(r => r.test(relPath));
-  }
-
-  _escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  }
-
-  _stripCommentsAndStrings(content) {
-    // Replace string literals with placeholder (preserve length approximately)
-    let result = content
-      // Template literals
-      .replace(/`[^`\\]*(?:\\[\s\S][^`\\]*)*`/g, '""')
-      // Double-quoted strings
-      .replace(/"[^"\\\n]*(?:\\.[^"\\\n]*)*"/g, '""')
-      // Single-quoted strings
-      .replace(/'[^'\\\n]*(?:\\.[^'\\\n]*)*'/g, "''")
-      // Block comments (JS/Java/Go/Rust/PHP/Kotlin)
-      .replace(/\/\*[\s\S]*?\*\//g, ' ')
-      // Line comments: //, #
-      .replace(/\/\/[^\n]*/g, ' ')
-      .replace(/#[^\n]*/g, ' ');
-    return result;
-  }
-}
-
-module.exports = GhostCodeDetector;