@quantizelab/quantize-brain 1.0.0

package/README.md

@@ -0,0 +1,170 @@
+# quantize-brain
+
+**Codebase Prompt Security Auditor CLI** by [Quantize Lab](https://www.quantizelab.dev)
+
+Automatically crawls your entire codebase, extracts every system prompt, and audits each one for injection vulnerabilities, jailbreaks, and data exfiltration vectors using the Quantize Lab Security API.
+
+[![npm version](https://img.shields.io/npm/v/@quantizelab/quantize-brain.svg)](https://www.npmjs.com/package/@quantizelab/quantize-brain)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+---
+
+## Installation
+
+```bash
+npm install -g @quantizelab/quantize-brain
+```
+
+Or run directly without installing:
+
+```bash
+npx @quantizelab/quantize-brain audit --api-key YOUR_KEY
+```
+
+---
+
+## Quick Start
+
+### 1. Get your API key
+
+Sign in at [quantizelab.dev](https://www.quantizelab.dev) → Profile → copy your **API Key**.
+
+### 2. Initialize config (optional)
+
+```bash
+quantize-brain init
+```
+
+Creates a `quantize-brain.json` in your project root with sensible defaults for ignored directories and scanned file extensions.
+
+### 3. Run an audit
+
+```bash
+quantize-brain audit --api-key sk_live_xxxxxxxxxxxx
+```
+
+---
+
+## Authentication
+
+You can supply your API key in three ways (highest priority first):
+
+| Method | Example |
+|---|---|
+| CLI flag | `--api-key sk_live_xxx` or `-k sk_live_xxx` |
+| `.env` file | `QUANTIZE_API_KEY=sk_live_xxx` |
+| Environment variable | `export QUANTIZE_API_KEY=sk_live_xxx` |
+
+### Using a `.env` file
+
+Create a `.env` file in your project root:
+
+```env
+QUANTIZE_API_KEY=sk_live_xxxxxxxxxxxx
+```
+
+Then just run:
+
+```bash
+quantize-brain audit
+```
+
+No flag needed — the CLI reads `.env` automatically with zero external dependencies.
+
+---
+
+## Commands
+
+### `quantize-brain init`
+
+Generates a `quantize-brain.json` configuration file in the current directory.
+
+```json
+{
+  "ignores": ["node_modules", ".git", ".next", "dist", "build"],
+  "extensions": [".js", ".ts", ".jsx", ".tsx", ".py", ".prompt", ".txt", ".md"],
+  "failOn": "high"
+}
+```
+
+### `quantize-brain audit [options]`
+
+Crawls the current workspace and audits all detected prompts.
+
+| Option | Description |
+|---|---|
+| `--api-key <key>`, `-k <key>` | Your Quantize Lab API key |
+| `--fail-on <severity>` | Exit with code 1 if severity meets threshold (`critical`, `high`, `medium`, `low`) |
+| `--host <url>` | Override the API host (default: `https://www.quantizelab.dev`) |
+| `--help`, `-h` | Show help |
+
+---
+
+## What Gets Detected
+
+The CLI scans for prompt declarations using pattern matching across:
+
+- **Variable assignments** — `systemPrompt = \`...\`` (JS/TS/Python)
+- **Multi-line strings** — `system_prompt = """..."""`
+- **Annotation blocks** — `// @quantize-prompt` or `// @decodes-prompt` followed by an assignment
+- **Dedicated files** — `*.prompt`, `system_prompt.txt`, `system-prompt.txt`
+
+---
+
+## CI/CD Integration
+
+Use `--fail-on` to gate your builds on security findings:
+
+```yaml
+# GitHub Actions example
+- name: Audit prompts
+  run: npx @quantizelab/quantize-brain audit --fail-on high
+  env:
+    QUANTIZE_API_KEY: ${{ secrets.QUANTIZE_API_KEY }}
+```
+
+Exit codes:
+- `0` — Clean, no findings at or above the threshold
+- `1` — Findings found at or above `--fail-on` severity
+
+---
+
+## Example Output
+
+```
+🔍 Crawling codebase for system prompts...
+Found 2 prompt(s). Starting security audit via Quantize Lab...
+
+────────────────────────────────────────────────────────────────────────────────
+📄 File: src/agent/system.ts:12
+💡 Source: System Prompt Variable
+Snippet: "You are a helpful assistant. Answer user questions truthfully..."
+🤖 Auditing...
+🛡️  Risk Score: 72/100
+Findings:
+  - [HIGH] Instruction Override Susceptibility
+    Issue: Prompt lacks explicit boundary enforcement...
+    Fix:   Add explicit role-lock instructions...
+
+================================================================================
+Audit complete.
+```
+
+---
+
+## Configuration File (`quantize-brain.json`)
+
+| Field | Type | Description |
+|---|---|---|
+| `ignores` | `string[]` | Directory/file names to skip during crawl |
+| `extensions` | `string[]` | File extensions to scan |
+| `failOn` | `string` | Default CI/CD failure threshold (`critical`, `high`, `medium`, `low`) |
+
+---
+
+## Links
+
+- 🌐 [quantizelab.dev](https://www.quantizelab.dev)
+- 📖 [Docs & API Reference](https://www.quantizelab.dev/docs/api)
+- 🔧 [MCP Server](https://www.npmjs.com/package/@quantizelab/mcp-server)
+- ⭐ [GitHub](https://github.com/thecodehaider/prompt-injection-scanner)

package/index.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// CLI Help Text
+const HELP_TEXT = `
+quantize-brain — Quantize Lab Codebase Prompt Security Auditor
+
+Usage:
+  quantize-brain init                   Initialize a quantize-brain.json configuration file.
+  quantize-brain audit [options]        Scan the current workspace for LLM system prompts and audit their security.
+
+Options:
+  --api-key, -k <key>                  Provide your Quantize Lab API Key (or set QUANTIZE_API_KEY env var).
+  --fail-on <severity>                 CI/CD mode: Exit with status 1 if findings meet or exceed severity level:
+                                       "critical", "high", "medium", or "low".
+  --host <url>                         Override Quantize Lab API host (default: https://www.quantizelab.dev).
+  --help, -h                           Show this help message.
+`;
+
+// Default settings
+const DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".env",
+  "venv",
+  "env",
+  "target",
+  "bin"
+];
+
+const DEFAULT_EXTENSIONS = [
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".py",
+  ".prompt",
+  ".txt",
+  ".md",
+  ".yaml",
+  ".yml"
+];
+
+// Helper to check files recursively
+function getFiles(dir, ignores, extensions, fileList = []) {
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+
+    const baseName = path.basename(filePath);
+    if (ignores.includes(baseName) || ignores.some(i => filePath.includes(path.sep + i + path.sep))) {
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      getFiles(filePath, ignores, extensions, fileList);
+    } else {
+      const ext = path.extname(filePath);
+      if (extensions.includes(ext)) {
+        fileList.push(filePath);
+      }
+    }
+  }
+  return fileList;
+}
+
+// Regex rules to detect prompt declarations
+const PROMPT_REGEXES = [
+  // JS/TS template literals and python multi-line strings:
+  // e.g. systemPrompt = `...` or system_prompt = """..."""
+  {
+    pattern: /(?:const|let|var|self\.)?(?:system_prompt|systemPrompt|sys_prompt|sysPrompt|system_instructions)\s*=\s*(?:"""|'''|`)([\s\S]*?)(?:"""|'''|`)/gi,
+    name: "System Prompt Variable"
+  },
+  // Standard single/double quoted strings
+  {
+    pattern: /(?:const|let|var|self\.)?(?:system_prompt|systemPrompt|sys_prompt|sysPrompt)\s*=\s*(?:"|')([\s\S]*?)(?:"|')/gi,
+    name: "System Prompt Short String"
+  },
+  // Special annotation block:
+  // @quantize-prompt or @decodes-prompt
+  {
+    pattern: /(?://|#)\s*@(?:quantize|decodes)-prompt\s*\r?\n(?:const|let|var|self\.)?\w*\s*=\s*(?:"""|'''|`|'|")([\s\S]*?)(?:"""|'''|`|'|")/gi,
+    name: "@quantize-prompt Annotation"
+  }
+];
+
+// Parse prompts out of a file
+function extractPrompts(filePath) {
+  const ext = path.extname(filePath);
+  const content = fs.readFileSync(filePath, "utf-8");
+  const prompts = [];
+
+  // If it's a dedicated prompt file, treat the whole file as the prompt
+  if (ext === ".prompt" || filePath.endsWith("system_prompt.txt") || filePath.endsWith("system-prompt.txt")) {
+    prompts.push({
+      type: "Dedicated Prompt File",
+      content: content.trim(),
+      line: 1
+    });
+    return prompts;
+  }
+
+  // Otherwise scan using regexes
+  for (const { pattern, name } of PROMPT_REGEXES) {
+    let match;
+    // Reset regex state
+    pattern.lastIndex = 0;
+    while ((match = pattern.exec(content)) !== null) {
+      const promptText = match[1].trim();
+      if (promptText.length > 20) { // Avoid false positives of empty/short variables
+        // Find line number
+        const charIndex = match.index;
+        const line = content.substring(0, charIndex).split("\n").length;
+        prompts.push({
+          type: name,
+          content: promptText,
+          line
+        });
+      }
+    }
+  }
+
+  return prompts;
+}
+
+// Log error and exit
+function fail(msg) {
+  console.error(`\x1b[31mError: ${msg}\x1b[0m`);
+  process.exit(1);
+}
+
+// Core execution
+async function main() {
+  const command = process.argv[2];
+
+  if (!command || command === "--help" || command === "-h") {
+    console.log(HELP_TEXT);
+    return;
+  }
+
+  if (command === "init") {
+    const configPath = path.join(process.cwd(), "quantize-brain.json");
+    if (fs.existsSync(configPath)) {
+      console.log("\x1b[33mquantize-brain.json already exists in this directory.\x1b[0m");
+      return;
+    }
+    const config = {
+      ignores: DEFAULT_IGNORES,
+      extensions: DEFAULT_EXTENSIONS,
+      failOn: "high"
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log("\x1b[32mSuccessfully created quantize-brain.json config file!\x1b[0m");
+    return;
+  }
+
+  if (command !== "audit") {
+    console.log(`Unknown command: ${command}`);
+    console.log(HELP_TEXT);
+    return;
+  }
+
+  // Helper to load keys from local .env files
+  function loadLocalEnv() {
+    const envPath = path.join(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+      try {
+        const content = fs.readFileSync(envPath, "utf-8");
+        const lines = content.split(/\r?\n/);
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith("#")) {
+            const firstEqual = trimmed.indexOf("=");
+            if (firstEqual !== -1) {
+              const key = trimmed.substring(0, firstEqual).trim();
+              const val = trimmed.substring(firstEqual + 1).trim();
+              const cleanVal = val.replace(/^["']|["']$/g, "");
+              if (key === "QUANTIZE_API_KEY") {
+                process.env[key] = cleanVal;
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Silently skip if error reading local .env
+      }
+    }
+  }
+
+  // Parse options
+  loadLocalEnv();
+  const args = process.argv.slice(3);
+  let apiKey = process.env.QUANTIZE_API_KEY;
+  let failOn = null;
+  let host = "https://www.quantizelab.dev";
+
+  // Load local config if exists
+  const configPath = path.join(process.cwd(), "quantize-brain.json");
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch (e) {
+      console.warn("Warning: Could not parse quantize-brain.json. Using defaults.");
+    }
+  }
+
+  const ignores = config.ignores || DEFAULT_IGNORES;
+  const extensions = config.extensions || DEFAULT_EXTENSIONS;
+  failOn = config.failOn || null;
+
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--api-key" || args[i] === "-k") && args[i + 1]) {
+      apiKey = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--api-key=")) {
+      apiKey = args[i].split("=")[1];
+    } else if (args[i] === "--fail-on" && args[i + 1]) {
+      failOn = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--fail-on=")) {
+      failOn = args[i].split("=")[1];
+    } else if (args[i] === "--host" && args[i + 1]) {
+      host = args[i + 1];
+      i++;
+    } else if (args[i].startsWith("--host=")) {
+      host = args[i].split("=")[1];
+    }
+  }
+
+  if (!apiKey) {
+    fail("No API key provided. Use --api-key <key> or set the QUANTIZE_API_KEY environment variable.");
+  }
+
+  if (host.endsWith("/")) {
+    host = host.slice(0, -1);
+  }
+
+  console.log("\x1b[36m🔍 Crawling codebase for system prompts...\x1b[0m");
+  const allFiles = getFiles(process.cwd(), ignores, extensions);
+  const foundPrompts = [];
+
+  for (const file of allFiles) {
+    const prompts = extractPrompts(file);
+    for (const p of prompts) {
+      foundPrompts.push({
+        file: path.relative(process.cwd(), file),
+        ...p
+      });
+    }
+  }
+
+  if (foundPrompts.length === 0) {
+    console.log("\x1b[32m✨ No prompts detected in the target directory!\x1b[0m");
+    return;
+  }
+
+  console.log(`\x1b[32mFound ${foundPrompts.length} prompt(s). Starting security audit via Quantize Lab...\x1b[0m\n`);
+
+  let maxSeverityLevel = 0; // 0 = None, 1 = Low, 2 = Medium, 3 = High, 4 = Critical
+  const severityMap = { low: 1, medium: 2, high: 3, critical: 4 };
+
+  for (const item of foundPrompts) {
+    console.log(`--------------------------------------------------------------------------------`);
+    console.log(`📄 \x1b[1mFile:\x1b[0m ${item.file}:${item.line}`);
+    console.log(`💡 \x1b[1mSource:\x1b[0m ${item.type}`);
+    console.log(`Snippet: "${item.content.substring(0, 80).replace(/\r?\n/g, " ")}..."`);
+    console.log(`🤖 \x1b[35mAuditing...\x1b[0m`);
+
+    try {
+      const response = await fetch(`${host}/api/v1/scan`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey
+        },
+        body: JSON.stringify({ prompt: item.content })
+      });
+
+      if (!response.ok) {
+        const errJson = await response.json().catch(() => ({}));
+        console.log(`\x1b[31m⚠️  Audit API failed: ${errJson.error || response.statusText}\x1b[0m`);
+        continue;
+      }
+
+      const report = await response.json();
+      const score = report.risk_score || 0;
+      let scoreColor = "\x1b[32m"; // Green
+      if (score >= 40) scoreColor = "\x1b[33m"; // Yellow
+      if (score >= 70) scoreColor = "\x1b[31m"; // Red
+
+      console.log(`🛡️  \x1b[1mRisk Score:\x1b[0m ${scoreColor}${score}/100\x1b[0m`);
+
+      if (report.findings && report.findings.length > 0) {
+        console.log(`\x1b[1mFindings:\x1b[0m`);
+        for (const finding of report.findings) {
+          const sev = (finding.severity || "low").toLowerCase();
+          const sevLevel = severityMap[sev] || 1;
+          if (sevLevel > maxSeverityLevel) {
+            maxSeverityLevel = sevLevel;
+          }
+
+          let sevColor = "\x1b[34m"; // Low - Blue
+          if (sev === "medium") sevColor = "\x1b[33m";
+          if (sev === "high" || sev === "critical") sevColor = "\x1b[31m";
+
+          console.log(`  - [${sevColor}${finding.severity.toUpperCase()}\x1b[0m] ${finding.category}`);
+          console.log(`    \x1b[2mIssue:\x1b[0m ${finding.description}`);
+          console.log(`    \x1b[2mFix:\x1b[0m   ${finding.fix}`);
+        }
+      } else {
+        console.log(`\x1b[32m✨ Clean! No critical vulnerabilities detected.\x1b[0m`);
+      }
+
+    } catch (e) {
+      console.log(`\x1b[31m⚠️  Error connecting to audit service: ${e.message}\x1b[0m`);
+    }
+  }
+
+  console.log(`================================================================================`);
+  console.log(`\x1b[32mAudit complete.\x1b[0m`);
+
+  // Handle CI/CD fail code
+  if (failOn) {
+    const failThreshold = severityMap[failOn.toLowerCase()];
+    if (failThreshold && maxSeverityLevel >= failThreshold) {
+      console.error(`\n\x1b[31m❌ CI/CD Build Failure: Found security vulnerabilities of level "${failOn}" or higher.\x1b[0m`);
+      process.exit(1);
+    }
+  }
+}
+
+main().catch(e => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@quantizelab/quantize-brain",
+  "version": "1.0.0",
+  "description": "Codebase prompt crawler and security scanner CLI by Quantize Lab",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "quantize-brain": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  }
+}