#!/usr/bin/env python3
"""NERO bounded read-only text triage, not antivirus or a security audit.
No target execution, dependency install, archive extraction or network access.
Usage: python triage-code.py EXTRACTED_DIRECTORY > review.json
Skip links, .git, node_modules, venv; <=2000 files, <=1MiB/file, <=64MiB total.
Signals need human review. No signals does not establish safety.
"""
import argparse
import datetime
import hashlib
import json
import os
import pathlib
import re

RULES = {
    'dynamic_execution': r'\b(?:eval|exec)\s*\(',
    'shell_or_process': r'\b(?:subprocess|os\.system|child_process|Invoke-Expression)\b',
    'download_and_execute': r'(?:curl|wget)[^\n]*\|\s*(?:sh|bash)|iex\s*\(',
    'unsafe_serialization_candidate': r'\b(?:pickle\.loads?|torch\.load|joblib\.load)\s*\(',
    'credential_access_candidate': r'\.ssh|\.aws|\.env\b|keyring|os\.environ',
    'install_hook_candidate': r'"(?:preinstall|postinstall|prepare)"\s*:|cmdclass\s*=',
    'privilege_or_persistence': r'\bsudo\b|crontab|LaunchAgents|CurrentVersion\\Run',
    'obfuscation_candidate': r'base64\.(?:b64decode|decodebytes)|FromBase64String',
    'remote_model_code': r'trust_remote_code\s*=\s*True',
}
EXTENSIONS = {'.py', '.sh', '.js', '.ts', '.mjs', '.cjs', '.ps1', '.bat', '.cmd', '.json', '.toml', '.yaml', '.yml', '.md', '.txt', '.rs', '.c', '.cpp', '.h'}
EXCLUDE = {'.git', 'node_modules', '.venv', 'venv', '__pycache__'}


def scan(root):
    root = pathlib.Path(root)
    if root.is_symlink() or not root.is_dir():
        raise ValueError('Select a real directory, not a symlink')
    report = {'tool': 'nero-triage-1', 'checked_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),
              'scope': __doc__, 'verdict': 'HUMAN_REVIEW_REQUIRED', 'files': [], 'skipped': [], 'errors': [],
              'limits': {'files': 2000, 'file_bytes': 1048576, 'total_bytes': 67108864}, 'limit_reached': False}
    total = 0
    stop = False
    def walk_error(error):
        report['errors'].append(str(error))
    for base, dirs, names in os.walk(root, followlinks=False, onerror=walk_error):
        dirs.sort()
        for d in dirs[:]:
            if d in EXCLUDE or pathlib.Path(base, d).is_symlink():
                report['skipped'].append({'path': str(pathlib.Path(base, d).relative_to(root)), 'reason': 'excluded directory or symlink'})
                dirs.remove(d)
        for name in sorted(names):
            p = pathlib.Path(base, name)
            rel = str(p.relative_to(root))
            try:
                if p.is_symlink() or not p.is_file() or p.suffix.lower() not in EXTENSIONS:
                    report['skipped'].append({'path': rel, 'reason': 'symlink, non-file or unsupported extension'})
                    continue
                if len(report['files']) >= 2000 or total >= 67108864:
                    report['limit_reached'] = True
                    stop = True
                    break
                with p.open('rb') as stream:
                    raw = stream.read(min(1048577, 67108864 - total + 1))
                if len(raw) > 1048576 or total + len(raw) > 67108864:
                    report['skipped'].append({'path': rel, 'reason': 'size limit'})
                    continue
                total += len(raw)
                if b'\x00' in raw:
                    report['skipped'].append({'path': rel, 'reason': 'binary content'})
                    continue
                text = raw.decode('utf-8')
                signals = [{'rule': rule, 'line': text.count('\n', 0, match.start()) + 1}
                           for rule, pattern in RULES.items() for match in re.finditer(pattern, text, re.I)]
                report['files'].append({'path': rel, 'sha256': hashlib.sha256(raw).hexdigest(), 'signals': signals})
            except (OSError, UnicodeError) as error:
                report['errors'].append({'path': rel, 'error': str(error)})
        if stop:
            break
    report['bytes_read'] = total
    report['coverage_complete'] = False
    return report


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('directory')
    args = parser.parse_args()
    try:
        print(json.dumps(scan(args.directory), indent=2))
    except (ValueError, OSError) as error:
        parser.exit(2, str(error) + '\n')
