@orionscanner/cli 0.1.0 → 0.1.1

package/README.md

@@ -1,248 +1,135 @@
-# Orion Security Suite (v0.1.0)
-
-<p align="center">
-  <img src="assets/logo.png" alt="Orion Security Suite" width="420" />
-</p>
-
-<p align="center">
-  <strong>Proprietary In-House Code Intelligence, Static Application Security Testing (SAST) & Architecture Auditing Platform</strong>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/version-0.1.0-blue.svg" alt="Version 0.1.0" />
-  <img src="https://img.shields.io/badge/license-Proprietary%20%2F%20In--House-green.svg" alt="License" />
-  <img src="https://img.shields.io/badge/python-%3E%3D3.10-blue.svg" alt="Python Version" />
-  <img src="https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg" alt="Platform" />
-  <img src="https://img.shields.io/badge/architecture-100%25%20In--House%20Local-purple.svg" alt="Architecture" />
-</p>
-
----
-
-## Executive Overview
-
-**Orion Security Suite** is a unified, enterprise-grade static analysis, software security, and architecture intelligence platform. Every auditing engine is **100% custom-built and developed in-house**, executing locally with zero third-party wrappers, zero external CLI subprocess dependencies, and zero telemetry.
-
-Orion operates on a unified **Intermediate Representation (IR)** graph, performing AST semantic analysis, Inter-Procedural Control Flow Graphs (CFG), Taint Propagation, AI/LLM agent defense, Cloud/IaC misconfiguration audits, and comprehensive PII/PCI-DSS privacy inspections.
-
----
-
-## Key Capabilities & Highlights
-
-| Capability | Orion Engine Architecture |
-| :--- | :--- |
-| **100% In-House Local IP** | All AST visitors, taint trackers, heuristics, and tokenizers run natively in pure Python. |
-| **Comprehensive Scope** | Single unified run covering Application Security, Cloud/IaC, AI Prompt/Agent Defense, Code Quality, and Architecture. |
-| **Phased Indexing** | Clear, multi-phase AST indexing and CFG synthesis without jumpy animations or progress-bar console jitter. |
-| **Cross-Engine Deduplication** | Correlates and collapses overlapping findings across multiple engines with confidence scoring. |
-| **Executive Reports** | Generates self-contained HTML dashboards with one-click print/PDF layout, JSON findings catalog, and TXT summaries in `ORION SCANNER REPORTS/`. |
-| **Isolated Execution** | Async/await execution model with per-engine resource limits, sandboxing, and timeout protection. |
-
----
-
-## Proprietary In-House Engine Suite
-
-Orion features a full matrix of specialized auditing engines grouped by domain:
-
-### 1. Application Security & Deep SAST
-- **DeepSAST™ (`sast`)**: Detects SQL Injection, XSS, Command Injection, SSRF, Path Traversal, Insecure Deserialization, and Weak Ciphers.
-- **TaintFlow™ (`taint`)**: Inter-procedural AST taint propagation tracking untrusted inputs to critical execution sinks.
-- **KeyVault™ (`secrets`)**: High-entropy token analysis and pattern matching for leaked API keys, private keys, and passwords.
-- **AuthGate™ (`authorization`)**: Route-level access control auditor verifying RBAC/ABAC enforcement across web frameworks.
-- **CryptoGuard™ (`crypto_guard`)**: Cryptographic posture validator flagging outdated algorithms (MD5, SHA1, DES, ECB mode).
-- **APIGuard™ (`api_security`)**: OWASP API Top 10 inspector auditing endpoint rate limiting, input validation, and JWT signatures.
-- **ContainerBreak™ (`sandbox_escape`)**: Detects sandbox escape vectors, unsafe reflection, `ctypes`, and dangerous native calls.
-
-### 2. AI, LLM & Threat Modeling
-- **AegisAgent™ (`llm_security` / `prompt_security`)**: Audits LLM applications for prompt injection, jailbreak attempts, unconstrained tool use, and insecure output handling.
-- **ThreatPulse™ (`threat_model`)**: Automated STRIDE threat modeling analyzing trust boundaries, unprotected persistence crossings, and cascading I/O.
-
-### 3. Privacy, Compliance & Supply Chain
-- **PrivacyShield™ (`sensitive_data`)**: Scans for PII, GDPR, HIPAA, and PCI-DSS violations with proprietary Luhn PAN validation and SSN detectors.
-- **DataBound™ (`data_residency`)**: Verifies data sovereignty and storage boundaries to prevent unauthorized geographic transfers.
-- **SBOMTracker™ (`supply_chain_sbom` / `deps`)**: In-house Software Bill of Materials (SBOM) generator and dependency vulnerability scanner.
-- **LicenseGuard™ (`license`)**: Scans for GPL/AGPL copyleft license contamination and license compatibility conflicts.
-- **ProvenanceTrace™ (`provenance`)**: Audits source code build integrity, commit signing indicators, and pipeline reproducibility.
-
-### 4. Code Quality, Standards & Reliability
-- **CognitivePulse™ (`complexity`)**: Computes cyclomatic complexity, cognitive load metrics, and deeply nested logic paths.
-- **CloneMatrix™ (`duplication`)**: Token-based duplicate code and structural redundancy detector.
-- **CleanSweep™ (`dead_import` / `orphan`)**: Identifies unreferenced symbols, orphan functions, and dead code stores.
-- **ResilienceGuard™ (`error_handling`)**: Detects empty exception handlers (`except: pass`), swallowed errors, and unhandled promises.
-- **CodeStandard™ (`lint`)**: Static code quality and best practices enforcement without stylistic noise.
-- **CoverageGuard™ (`test_coverage`)**: Heuristic test-to-code ratio and missing unit test coverage detector.
-
-### 5. Architecture, Dataflow & Performance
-- **CallGraph360™ (`callgraph`)**: Constructs comprehensive whole-program call graphs and dependency coupling hierarchies.
-- **FlowCFG™ (`cfg`)**: Builds control flow graphs to detect unreachable branches, infinite loops, and execution anomalies.
-- **SymbolMatrix™ (`symbol`)**: Analyzes symbol resolution, shadowed builtins, and scope collisions.
-- **DataFlowIR™ (`dataflow`)**: Intra-function data flow analyzer detecting use-before-def and uninitialized state.
-- **SpeedGuard™ (`perf_guard`)**: Identifies algorithmic performance anti-patterns, nested O(n²) loops, and unindexed lookups.
-- **RegressionShield™ (`regression`)**: Flags fragile patterns, runtime monkey patching, and unsafe reflection.
-- **WiringTrace™ (`wiring_trace`)**: Dependency injection and component wiring validator.
-- **StateGuard™ (`state`)**: Concurrency analysis detecting unprotected shared mutable state and race conditions.
-
-### 6. Cloud, IaC & Resilience
-- **CloudSentry™ (`container`)**: Dockerfile and container security analyzer (root execution, exposed daemon sockets, multi-stage builds).
-- **IaCGuard™ (`iac_security`)**: Terraform, CloudFormation, and Kubernetes manifest auditor for security group and IAM misconfigurations.
-- **ConfigPulse™ (`config_engine` / `config_validation`)**: Validates environment variables, `.env` hygiene, and application configuration drift.
-- **ChaosProbe™ (`chaos` / `chaos_config`)**: Injects fault tolerance simulations and verifies circuit breaker recovery mechanisms.
-- **NoiseFilter™ (`noise`)**: Machine-level false positive suppression and signal-to-noise optimization.
-- **HunterCore™ (`hunter`)**: Heuristic zero-day vulnerability hunter for unusual code patterns.
-- **FPLearn™ (`fp_learn`)**: Contextual learning feedback loop to minimize recurring false positives.
-
----
-
-## Quick Start & Installation
-
-### Local Editable Installation
-
-```bash
-# Clone or navigate to the Orion Engine repository
-cd D:/Homeworks/Orion_Engine
-
-# Install in editable mode
-pip install -e .
-```
-
-### Verification
-
-```bash
-orion --help
-```
-
----
-
-## Command Line Interface (CLI)
-
-Orion provides a formatted CLI with steady status reporting and dedicated sections for **Security Vulnerabilities** and **Code Quality Standards**:
-
-```bash
-# Run a full audit across all proprietary engines on current directory
-orion .
-
-# Audit a specific repository or file
-orion /path/to/project
-orion ./src/app.py
-
-# Specialized Targeted Scans:
-orion . --security       # Application Security & Deep SAST
-orion . --threat         # Automated STRIDE Threat Modeling & Privacy (PII)
-orion . --iac            # Infrastructure as Code & Container Security
-orion . --ai             # AI, LLM Prompt Security & Agent Defense
-orion . --quality        # Code Quality, Complexity & Linter
-orion . --architecture   # Call Graph, CFG & Data Flow Analysis
-orion . --supply-chain   # SBOM, Dependencies & License Auditing
-
-# Interactive Management Console:
-orion
-```
-
----
-
-## Executive Reporting Outputs
-
-Every execution automatically cleans previous artifacts and produces three reports in `ORION SCANNER REPORTS/`:
-
-1. **`orion_executive_security_report.html`**:
-   - High-clarity executive security dashboard.
-   - Interactive severity (`Critical`, `High`, `Medium`, `Low`) and category filter tabs (`Security`, `Code Quality`, `Architecture`, `Supply Chain`).
-   - Clean, self-contained layout with zero external CSS/JS dependencies.
-   - Built-in **🖨️ Export PDF / Print Report** stylesheet optimized for executive presentations.
-2. **`orion_executive_security_report.json`**:
-   - Machine-readable structured findings catalog with metadata, CWE identifiers, confidence scores, and contributing engine attribution.
-3. **`orion_executive_security_report.txt`**:
-   - Clean plaintext audit summary ideal for CI/CD terminal logs and build pipelines.
-
----
-
-## Python Programmatic API
-
-You can integrate Orion directly into custom Python pipelines:
-
-```python
-import asyncio
-from pathlib import Path
-from orion.engine import OrionEngine, EngineConfig, ResourceLimits
-from orion.engine.ir import OrionIR
-
-async def audit_codebase():
-    # 1. Initialize Orion Engine
-    engine = OrionEngine()
-
-    # 2. Build Intermediate Representation (IR)
-    file_path = Path("src/server.py")
-    ir = OrionIR(
-        content=file_path.read_bytes(),
-        metadata={
-            "path": str(file_path),
-            "language": "python",
-            "project_root": "."
-        }
-    )
-
-    # 3. Configure Execution Limits
-    config = EngineConfig(
-        resource_limits=ResourceLimits(
-            max_cpu_seconds=30,
-            max_memory_mb=256
-        )
-    )
-
-    # 4. Execute Engine Suite
-    result = await engine.run([ir], config)
-
-    # 5. Process Findings
-    print(f"Total Findings: {len(result.findings)}")
-    for finding in result.findings:
-        print(f"[{finding.severity.upper()}] {finding.title} ({finding.location})")
-        print(f"  Engine: {finding.engine} | Confidence: {finding.metadata.get('confidence')}")
-
-if __name__ == "__main__":
-    asyncio.run(audit_codebase())
-```
-
----
-
-## Supported Languages & File Formats
-
-Orion automatically detects and audits:
-- **Languages**: Python (`.py`), JavaScript (`.js`, `.jsx`, `.mjs`), TypeScript (`.ts`, `.tsx`), Go (`.go`), Java (`.java`), Rust (`.rs`), Ruby (`.rb`), PHP (`.php`), C/C++ (`.c`, `.cpp`, `.h`), C# (`.cs`), Shell (`.sh`, `.bash`), SQL (`.sql`).
-- **Infrastructure & Configs**: Dockerfile, `docker-compose.yml`, Kubernetes manifests (`.yaml`, `.yml`), Terraform (`.tf`), GitHub Actions workflows (`.github/workflows/*.yml`), `.env` configuration files.
-- **Manifests & Dependencies**: `requirements.txt`, `pyproject.toml`, `Pipfile`, `package.json`, `package-lock.json`, `go.mod`, `Cargo.toml`, `pom.xml`.
-
----
-
-## Project Structure
-
-```text
-Orion_Engine/
-├── assets/
-│   └── logo.png                       # Official Orion Emblem & Logo
-├── src/
-│   └── orion/
-│       └── engine/
-│           ├── core.py                # OrionEngine Core Coordinator
-│           ├── ir.py                  # Intermediate Representation (IR)
-│           ├── runner.py              # CLI Runner, Formatter & Report Generator
-│           ├── registry.py            # Dynamic In-House Engine Discovery
-│           ├── config.py              # Engine Configurations & Resource Limits
-│           ├── results.py             # Finding & EngineResult Data Models
-│           ├── sast/                  # DeepSAST™ Engine
-│           ├── taint/                 # TaintFlow™ Engine
-│           ├── secrets/               # KeyVault™ Engine
-│           ├── threat_model/          # ThreatPulse™ STRIDE Engine
-│           ├── sensitive_data/        # PrivacyShield™ PII/PCI Engine
-│           ├── llm_security/          # AegisAgent™ AI/LLM Security Engine
-│           ├── perf_guard/            # SpeedGuard™ Performance Engine
-│           ├── iac_security/          # IaCGuard™ Cloud/IaC Engine
-│           └── ...                    # (All in-house proprietary engines)
-├── ORION SCANNER REPORTS/             # Output Directory for Latest Generated Reports
-├── pyproject.toml                     # Package Configuration (v0.1.0)
-└── README.md                          # Documentation
-```
-
----
-
-## License & Compliance
-
-Orion Security Suite is a proprietary, in-house developed codebase intelligence platform. All engines, AST visitors, and parsers are original intellectual property engineered to run self-contained on local infrastructure.
+# Orion Security Suite
+
+<p align="center">
+  <img src="assets/logo.png" alt="Orion Security Suite" width="460" />
+</p>
+
+<p align="center">
+  <strong>SEE. ANALYZE. IMPROVE.</strong><br>
+  <em>The Autonomous, In-House Code Intelligence & Enterprise Security Audit Platform</em>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@orionscanner/cli"><img src="https://img.shields.io/badge/npm-v0.1.0-cb3837?logo=npm" alt="npm" /></a>
+  <img src="https://img.shields.io/badge/version-0.1.0-blue.svg" alt="Version 0.1.0" />
+  <img src="https://img.shields.io/badge/security-In--House%20Core-emerald.svg" alt="Security" />
+  <img src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg" alt="Platform" />
+</p>
+
+---
+
+## Why Choose Orion?
+
+Modern development teams face fragmented security tools, high false-alarm noise, and code privacy risks from sending proprietary source files to third-party clouds.
+
+**Orion Security Suite** solves this with a unified, zero-cloud, 100% in-house code audit powerhouse that runs entirely on your local infrastructure.
+
+```
+                  ┌────────────────────────────────────────┐
+                  │          ORION SECURITY SUITE          │
+                  │        SEE. ANALYZE. IMPROVE.          │
+                  └───────────────────┬────────────────────┘
+                                      │
+         ┌────────────────────────────┼────────────────────────────┐
+         ▼                            ▼                            ▼
+  🛡️ Application Security      🧠 AI & LLM Defense          ⚡ Code Quality & Flow
+  • Deep SAST & Sinks          • Prompt Injection Shields   • Complexity & O(n²) Guard
+  • Taint Flow Analysis        • Agent Trust Boundaries     • Dead Code Elimination
+  • Secret & Key Leak Hunter   • Automated STRIDE Threat    • Clean Architecture Graph
+```
+
+---
+
+## Instant Quick Start
+
+### 🚀 Install via NPM (One-Line Global Setup)
+
+```bash
+npm install -g @orionscanner/cli
+```
+
+*Or run instantly with `npx` (zero installation required):*
+```bash
+npx @orionscanner/cli .
+```
+
+---
+
+### 🐍 Install via Python
+
+```bash
+# Clone the repository
+git clone https://github.com/chandrahotha/OrionEngine.git
+cd OrionEngine
+
+# Install locally in editable mode
+pip install -e .
+```
+
+---
+
+## ⚡ Supercharged CLI Experience
+
+Audit your entire codebase in seconds with intuitive commands:
+
+```bash
+# Complete Workspace Audit (All Security, Quality & Architecture Engines)
+orion .
+
+# Targeted Security & Deep SAST Audit
+orion . --security
+
+# Automated STRIDE Threat Modeling & PII Privacy Inspection
+orion . --threat
+
+# AI Agent Defense & Prompt Injection Testing
+orion . --ai
+
+# Cloud Configuration & Container Security Audit
+orion . --iac
+
+# Code Quality, Complexity & Architecture Sweep
+orion . --quality
+
+# Launch Interactive Terminal Management Console
+orion
+```
+
+---
+
+## 💎 The Orion Advantage
+
+### 🔒 100% In-House, Zero-Cloud Privacy
+Your proprietary source code never leaves your workstation or CI/CD runner. Every parser, AST visitor, heuristic rule, and taint-flow engine is 100% custom-built and executes locally with zero external subprocess dependencies.
+
+### 📊 Beautiful, Executive-Ready Reports
+Every scan generates self-contained executive intelligence reports in `ORION SCANNER REPORTS/`:
+- **Interactive HTML Dashboard**: Filter findings by category (`Security`, `Code Quality`, `Architecture`, `Supply Chain`) and severity.
+- **One-Click PDF Export**: Clean, printable executive summary ready for stakeholders and compliance audits.
+- **Machine-Readable JSON**: Complete structured finding metadata with CWE mappings and confidence scores.
+
+### 🎯 High-Precision Signal, Zero Fluff
+Orion uses cross-engine correlation and false-positive suppression to eliminate noise, delivering actionable findings you can trust.
+
+---
+
+## 🛠️ Multi-Language Codebase Support
+
+Orion automatically detects and audits your entire multi-language stack:
+
+- **Languages**: Python, JavaScript, TypeScript, Go, Java, Rust, Ruby, PHP, C/C++, C#, Shell, SQL
+- **Cloud & DevOps**: Dockerfile, `docker-compose.yml`, Kubernetes Manifests, Terraform, GitHub Actions
+- **Dependency Manifests**: `package.json`, `requirements.txt`, `pyproject.toml`, `go.mod`, `Cargo.toml`, `pom.xml`
+
+---
+
+## 📦 NPM Package Links
+
+- **NPM Package**: [`https://www.npmjs.com/package/@orionscanner/cli`](https://www.npmjs.com/package/@orionscanner/cli)
+- **GitHub Repository**: [`https://github.com/chandrahotha/OrionEngine`](https://github.com/chandrahotha/OrionEngine)
+
+---
+
+## License & Intellectual Property
+
+Orion Security Suite is a proprietary, in-house developed codebase intelligence platform. All engines, algorithms, and AST analyzers are original intellectual property built for high-performance security auditing.

package/bin/orion.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 /**
- * Orion Security Suite - Global NPM CLI Wrapper (v0.1.0)
+ * Orion Security Suite - Protected Standalone Binary Wrapper (v0.1.1)
  * 100% In-House Code Intelligence & SAST Platform
+ * (Zero Python Source Code Distributed)
  */
 
 const { spawn } = require('child_process');
@@ -11,38 +12,38 @@ const fs = require('fs');
 const projectRoot = path.resolve(__dirname, '..');
 const args = process.argv.slice(2);
 
-function runPython(pythonCmd) {
-    const pythonEnv = Object.assign({}, process.env, {
-        PYTHONPATH: path.join(projectRoot, 'src') + (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : '')
-    });
+// Check for standalone compiled binary first (zero source code)
+const exePath = path.join(projectRoot, 'dist', 'orion.exe');
+const binPath = path.join(projectRoot, 'dist', 'orion');
 
-    const scriptPath = path.join(projectRoot, 'src', 'orion', 'engine', 'runner.py');
-    const child = spawn(pythonCmd, [scriptPath, ...args], {
+if (process.platform === 'win32' && fs.existsSync(exePath)) {
+    const child = spawn(exePath, args, {
         stdio: 'inherit',
-        env: pythonEnv,
         cwd: process.cwd()
     });
-
-    child.on('error', (err) => {
-        if (pythonCmd === 'python3') {
-            runPython('python');
-        } else if (pythonCmd === 'python') {
-            runPython('py');
-        } else {
-            console.error('\x1b[31m✖ Error: Python 3.10+ is required to execute Orion Engine.\x1b[0m');
-            console.error('Please ensure Python is installed and added to your PATH environment variable.');
-            process.exit(1);
-        }
-    });
-
-    child.on('close', (code) => {
-        process.exit(code || 0);
+    child.on('close', (code) => process.exit(code || 0));
+} else if (fs.existsSync(binPath)) {
+    const child = spawn(binPath, args, {
+        stdio: 'inherit',
+        cwd: process.cwd()
     });
-}
-
-// Start with standard python executable or python3
-if (process.platform === 'win32') {
-    runPython('python');
+    child.on('close', (code) => process.exit(code || 0));
 } else {
-    runPython('python3');
+    // Fallback if running from development workspace with source
+    const scriptPath = path.join(projectRoot, 'src', 'orion', 'engine', 'runner.py');
+    if (fs.existsSync(scriptPath)) {
+        const pythonEnv = Object.assign({}, process.env, {
+            PYTHONPATH: path.join(projectRoot, 'src') + (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : '')
+        });
+        const cmd = process.platform === 'win32' ? 'python' : 'python3';
+        const child = spawn(cmd, [scriptPath, ...args], {
+            stdio: 'inherit',
+            env: pythonEnv,
+            cwd: process.cwd()
+        });
+        child.on('close', (code) => process.exit(code || 0));
+    } else {
+        console.error('\x1b[31m✖ Error: Orion binary executable not found.\x1b[0m');
+        process.exit(1);
+    }
 }

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@orionscanner/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Orion Security Suite - Proprietary In-House Code Intelligence, SAST & Architecture Auditing Platform",
   "main": "bin/orion.js",
   "bin": {
-    "orion": "./bin/orion.js",
-    "orion-engine": "./bin/orion.js",
-    "orion-cli": "./bin/orion.js"
+    "orion": "bin/orion.js",
+    "orion-engine": "bin/orion.js",
+    "orion-cli": "bin/orion.js"
   },
   "scripts": {
-    "start": "node ./bin/orion.js",
-    "orion": "node ./bin/orion.js"
+    "start": "node bin/orion.js",
+    "orion": "node bin/orion.js"
   },
   "keywords": [
     "orion",
@@ -39,10 +39,8 @@
   "homepage": "https://github.com/chandrahotha/OrionEngine#readme",
   "files": [
     "bin/",
-    "src/",
+    "dist/",
     "assets/",
-    "docs/",
-    "README.md",
-    "pyproject.toml"
+    "README.md"
   ]
 }