agent-security 1.0.0__tar.gz

agent_security-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nerq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_security-1.0.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: agent-security
+Version: 1.0.0
+Summary: Security scanner for AI agent dependencies. One command to know if your AI stack is safe.
+Home-page: https://nerq.ai
+Author: Nerq
+Author-email: hello@nerq.ai
+License: MIT
+Project-URL: Homepage, https://nerq.ai
+Project-URL: Documentation, https://nerq.ai/start
+Project-URL: Repository, https://github.com/agentic-index/agent-security
+Keywords: ai,agents,security,trust,cve,scanner,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# agent-security
+
+**Know if your AI dependencies are safe. One command.**
+
+```bash
+pip install agent-security
+agent-security scan requirements.txt
+```
+
+Scans all your AI agent dependencies against Nerq's trust database of 204,000+ agents.
+Checks for CVEs, license issues, maintenance status, and overall trust score.
+
+## Output
+
+```
+agent-security scan: requirements.txt
+Scanned 12 dependencies
+
+  OK  langchain: Trust 88 (A), MIT
+  OK  openai: Trust 91 (A+), MIT
+  !!  some-agent: Trust 48 (C), 1 CVE(s), no license
+  !!  risky-tool: Trust 29 (D), 2 CVE(s), AGPL
+
+Summary: 10 trusted, 1 warning(s), 1 critical
+
+Run 'agent-security fix requirements.txt' for improvement recommendations.
+```
+
+## Commands
+
+### scan
+
+```bash
+agent-security scan requirements.txt
+agent-security scan package.json
+agent-security scan pyproject.toml
+agent-security scan requirements.txt --ci  # exits 1 if critical issues
+```
+
+### fix
+
+```bash
+agent-security fix requirements.txt
+```
+
+Shows specific recommendations for each problematic dependency:
+- Alternative packages with higher trust scores
+- CVE details and update suggestions
+
+### check
+
+```bash
+agent-security check langchain
+agent-security check auto-gpt
+```
+
+Check trust for a single package.
+
+### badge
+
+```bash
+agent-security badge my-project
+```
+
+Generates markdown for a Nerq trust badge to add to your README.
+
+### ci
+
+```bash
+agent-security ci
+```
+
+Outputs a ready-to-use GitHub Action YAML for automated trust checking on every PR.
+
+## Supported files
+
+- `requirements.txt` — Python dependencies
+- `package.json` — Node.js dependencies
+- `pyproject.toml` — Python project dependencies
+
+## How it works
+
+agent-security calls the [Nerq API](https://nerq.ai/v1/preflight) for each dependency.
+Every package is scored on:
+
+- **Security** — Known CVEs and vulnerability history
+- **Maintenance** — Update frequency, issue response time
+- **Popularity** — Stars, downloads, community size
+- **License** — SPDX compliance, commercial friendliness
+- **Ecosystem** — Framework compatibility, integration quality
+
+No API key required. Free to use.
+
+## CI Integration
+
+Add to `.github/workflows/trust-check.yml`:
+
+```yaml
+name: Agent Security Check
+on: [push, pull_request]
+
+jobs:
+  trust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install agent-security
+      - run: agent-security scan requirements.txt --ci
+```
+
+## License
+
+MIT

agent_security-1.0.0/README.md

@@ -0,0 +1,116 @@
+# agent-security
+
+**Know if your AI dependencies are safe. One command.**
+
+```bash
+pip install agent-security
+agent-security scan requirements.txt
+```
+
+Scans all your AI agent dependencies against Nerq's trust database of 204,000+ agents.
+Checks for CVEs, license issues, maintenance status, and overall trust score.
+
+## Output
+
+```
+agent-security scan: requirements.txt
+Scanned 12 dependencies
+
+  OK  langchain: Trust 88 (A), MIT
+  OK  openai: Trust 91 (A+), MIT
+  !!  some-agent: Trust 48 (C), 1 CVE(s), no license
+  !!  risky-tool: Trust 29 (D), 2 CVE(s), AGPL
+
+Summary: 10 trusted, 1 warning(s), 1 critical
+
+Run 'agent-security fix requirements.txt' for improvement recommendations.
+```
+
+## Commands
+
+### scan
+
+```bash
+agent-security scan requirements.txt
+agent-security scan package.json
+agent-security scan pyproject.toml
+agent-security scan requirements.txt --ci  # exits 1 if critical issues
+```
+
+### fix
+
+```bash
+agent-security fix requirements.txt
+```
+
+Shows specific recommendations for each problematic dependency:
+- Alternative packages with higher trust scores
+- CVE details and update suggestions
+
+### check
+
+```bash
+agent-security check langchain
+agent-security check auto-gpt
+```
+
+Check trust for a single package.
+
+### badge
+
+```bash
+agent-security badge my-project
+```
+
+Generates markdown for a Nerq trust badge to add to your README.
+
+### ci
+
+```bash
+agent-security ci
+```
+
+Outputs a ready-to-use GitHub Action YAML for automated trust checking on every PR.
+
+## Supported files
+
+- `requirements.txt` — Python dependencies
+- `package.json` — Node.js dependencies
+- `pyproject.toml` — Python project dependencies
+
+## How it works
+
+agent-security calls the [Nerq API](https://nerq.ai/v1/preflight) for each dependency.
+Every package is scored on:
+
+- **Security** — Known CVEs and vulnerability history
+- **Maintenance** — Update frequency, issue response time
+- **Popularity** — Stars, downloads, community size
+- **License** — SPDX compliance, commercial friendliness
+- **Ecosystem** — Framework compatibility, integration quality
+
+No API key required. Free to use.
+
+## CI Integration
+
+Add to `.github/workflows/trust-check.yml`:
+
+```yaml
+name: Agent Security Check
+on: [push, pull_request]
+
+jobs:
+  trust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install agent-security
+      - run: agent-security scan requirements.txt --ci
+```
+
+## License
+
+MIT

agent_security-1.0.0/agent_security/__init__.py

@@ -0,0 +1,3 @@
+"""agent-security — Know if your AI dependencies are safe. One command."""
+
+__version__ = "1.0.0"

agent_security-1.0.0/agent_security/cli.py

@@ -0,0 +1,114 @@
+"""CLI entry point for agent-security."""
+
+import sys
+from agent_security.scanner import scan_file, detect_and_parse, check_trust
+from agent_security.reporter import (
+    format_scan_report, format_fix_report, generate_badge_markdown,
+    generate_github_action, bold
+)
+
+
+def main():
+    args = sys.argv[1:]
+
+    if not args or args[0] in ("--help", "-h", "help"):
+        print_help()
+        return
+
+    command = args[0]
+    api_url = None
+
+    # Extract --api-url flag if present
+    for i, arg in enumerate(args):
+        if arg == "--api-url" and i + 1 < len(args):
+            api_url = args[i + 1]
+            args = args[:i] + args[i + 2:]
+            break
+
+    if command == "scan":
+        if len(args) < 2:
+            print("Usage: agent-security scan <requirements.txt|package.json|pyproject.toml>")
+            sys.exit(1)
+        filepath = args[1]
+        ci_mode = "--ci" in args
+
+        print(f"Scanning {filepath}...")
+        results = scan_file(filepath, api_url)
+        print(format_scan_report(results, filepath))
+
+        if ci_mode:
+            critical = sum(1 for r in results if r["trust_score"] is not None and r["trust_score"] < 40)
+            if critical > 0:
+                sys.exit(1)
+
+    elif command == "fix":
+        if len(args) < 2:
+            print("Usage: agent-security fix <requirements.txt|package.json|pyproject.toml>")
+            sys.exit(1)
+        filepath = args[1]
+        results = scan_file(filepath, api_url)
+        print(format_fix_report(results))
+
+    elif command == "badge":
+        name = args[1] if len(args) > 1 else "my-project"
+        print(f"\nAdd this to your README:\n")
+        print(f"  {generate_badge_markdown(name)}\n")
+
+    elif command == "ci":
+        print(f"\nAdd this to .github/workflows/trust-check.yml:\n")
+        print(generate_github_action())
+
+    elif command == "check":
+        if len(args) < 2:
+            print("Usage: agent-security check <package-name>")
+            sys.exit(1)
+        name = args[1]
+        result = check_trust(name, api_url)
+        if result["error"]:
+            print(f"  {name}: not found ({result['error']})")
+        else:
+            trust = int(result["trust_score"]) if result["trust_score"] else "?"
+            grade = result["grade"] or "?"
+            print(f"  {name}: Trust {trust} ({grade}) — {result['recommendation']}")
+            if result["cve_count"]:
+                print(f"  CVEs: {result['cve_count']}")
+            if result["license"]:
+                print(f"  License: {result['license']}")
+
+    else:
+        print(f"Unknown command: {command}")
+        print_help()
+        sys.exit(1)
+
+
+def print_help():
+    print("""
+agent-security — Know if your AI dependencies are safe. One command.
+
+Commands:
+  scan <file>     Scan dependencies for trust scores and CVEs
+  fix <file>      Show fix recommendations for problematic dependencies
+  check <name>    Check trust for a single package
+  badge [name]    Generate Nerq trust badge markdown
+  ci              Generate GitHub Action YAML for CI integration
+
+Supported files:
+  requirements.txt, package.json, pyproject.toml
+
+Options:
+  --ci            Exit with code 1 if critical issues found (for CI)
+  --api-url URL   Override Nerq API URL
+
+Examples:
+  agent-security scan requirements.txt
+  agent-security fix package.json
+  agent-security check langchain
+  agent-security badge my-project
+  agent-security ci
+
+Powered by nerq.ai — the trust layer for AI agents.
+""")
+
+
+if __name__ == "__main__":
+    main()

agent_security-1.0.0/agent_security/reporter.py

@@ -0,0 +1,135 @@
+"""Format scan results for terminal output."""
+
+import sys
+
+
+def _color(text, code):
+    """Apply ANSI color if stdout is a terminal."""
+    if not sys.stdout.isatty():
+        return text
+    return f"\033[{code}m{text}\033[0m"
+
+
+def green(text): return _color(text, "32")
+def yellow(text): return _color(text, "33")
+def red(text): return _color(text, "31")
+def bold(text): return _color(text, "1")
+def dim(text): return _color(text, "2")
+
+
+def format_scan_report(results, filepath):
+    """Format scan results as a terminal report."""
+    lines = []
+    lines.append(f"\n{bold('agent-security')} scan: {filepath}")
+    lines.append(f"Scanned {len(results)} dependencies\n")
+
+    trusted = 0
+    warnings = 0
+    critical = 0
+    not_found = 0
+
+    for r in results:
+        name = r["name"]
+        trust = r["trust_score"]
+        grade = r["grade"] or "?"
+        rec = r["recommendation"] or "UNKNOWN"
+        cves = r["cve_count"]
+        lic = r["license"] or "unknown"
+        error = r["error"]
+
+        if error:
+            not_found += 1
+            lines.append(f"  {dim('?')}  {name}: {dim('not found in index')}")
+            continue
+
+        trust_str = f"{int(trust)}" if trust is not None else "?"
+        cve_str = f", {cves} CVE(s)" if cves else ""
+        lic_str = f", {lic}" if lic and lic != "unknown" else ""
+
+        if rec == "ALLOW" or (trust is not None and trust >= 70):
+            trusted += 1
+            icon = green("OK")
+            detail = f"Trust {trust_str} ({grade}){cve_str}{lic_str}"
+            lines.append(f"  {icon}  {name}: {detail}")
+        elif rec == "DENY" or (trust is not None and trust < 40):
+            critical += 1
+            icon = red("!!")
+            detail = f"Trust {trust_str} ({grade}){cve_str}{lic_str}"
+            lines.append(f"  {icon}  {red(name)}: {detail}")
+        else:
+            warnings += 1
+            icon = yellow("!!")
+            detail = f"Trust {trust_str} ({grade}){cve_str}{lic_str}"
+            lines.append(f"  {icon}  {yellow(name)}: {detail}")
+
+    lines.append("")
+    summary_parts = []
+    if trusted:
+        summary_parts.append(green(f"{trusted} trusted"))
+    if warnings:
+        summary_parts.append(yellow(f"{warnings} warning(s)"))
+    if critical:
+        summary_parts.append(red(f"{critical} critical"))
+    if not_found:
+        summary_parts.append(dim(f"{not_found} not found"))
+    lines.append(f"Summary: {', '.join(summary_parts)}")
+
+    if critical > 0:
+        lines.append(f"\nRun '{bold('agent-security fix ' + filepath)}' for improvement recommendations.")
+
+    return "\n".join(lines)
+
+
+def format_fix_report(results):
+    """Format fix recommendations."""
+    lines = []
+    lines.append(f"\n{bold('agent-security')} fix recommendations:\n")
+
+    problematic = [r for r in results if r["trust_score"] is not None and r["trust_score"] < 60]
+
+    if not problematic:
+        lines.append("  All dependencies look good. No fixes needed.")
+        return "\n".join(lines)
+
+    for r in problematic:
+        trust = int(r["trust_score"]) if r["trust_score"] else "?"
+        lines.append(f"  {bold(r['name'])} (Trust: {trust}):")
+
+        if r["cve_count"]:
+            lines.append(f"    -> {r['cve_count']} known CVE(s) — check for updates")
+
+        alts = r.get("alternatives", [])
+        if alts:
+            alt = alts[0]
+            alt_name = alt.get("name", "?")
+            alt_trust = int(alt.get("trust_score", 0))
+            lines.append(f"    -> Alternative: {green(alt_name)} (Trust: {alt_trust})")
+        else:
+            lines.append(f"    -> No direct alternative found. Review manually.")
+
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_badge_markdown(project_name="my-project"):
+    """Generate Nerq trust badge markdown."""
+    return f"[![Nerq Trust](https://nerq.ai/v1/badge/{project_name})](https://nerq.ai/safe/{project_name})"
+
+
+def generate_github_action():
+    """Generate GitHub Action YAML for trust checking."""
+    return """name: Agent Security Check
+on: [push, pull_request]
+
+jobs:
+  trust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install agent-security
+      - run: agent-security scan requirements.txt --ci
+"""

agent_security-1.0.0/agent_security/scanner.py

@@ -0,0 +1,109 @@
+"""Scan dependency files for AI agent trust scores."""
+
+import json
+import re
+import urllib.request
+import urllib.parse
+from pathlib import Path
+
+API_URL = "https://nerq.ai"
+
+
+def parse_requirements(filepath):
+    """Parse requirements.txt and return list of package names."""
+    packages = []
+    with open(filepath) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or line.startswith("-"):
+                continue
+            # Strip version specifiers
+            name = re.split(r"[>=<!\[;]", line)[0].strip()
+            if name:
+                packages.append(name)
+    return packages
+
+
+def parse_package_json(filepath):
+    """Parse package.json and return list of dependency names."""
+    with open(filepath) as f:
+        data = json.load(f)
+    deps = list(data.get("dependencies", {}).keys())
+    deps += list(data.get("devDependencies", {}).keys())
+    return deps
+
+
+def parse_pyproject(filepath):
+    """Parse pyproject.toml for dependencies (basic parser)."""
+    packages = []
+    in_deps = False
+    with open(filepath) as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith("dependencies") and "=" in line:
+                in_deps = True
+                continue
+            if in_deps:
+                if line == "]":
+                    in_deps = False
+                    continue
+                # Extract package name from "package>=1.0"
+                match = re.match(r'"([a-zA-Z0-9_-]+)', line)
+                if match:
+                    packages.append(match.group(1))
+    return packages
+
+
+def detect_and_parse(filepath):
+    """Auto-detect file type and parse dependencies."""
+    p = Path(filepath)
+    name = p.name.lower()
+
+    if name == "requirements.txt" or name.endswith(".txt"):
+        return parse_requirements(filepath)
+    elif name == "package.json":
+        return parse_package_json(filepath)
+    elif name == "pyproject.toml":
+        return parse_pyproject(filepath)
+    else:
+        # Try requirements.txt format as fallback
+        return parse_requirements(filepath)
+
+
+def check_trust(package_name, api_url=None):
+    """Check trust score for a single package."""
+    base = api_url or API_URL
+    url = f"{base}/v1/preflight?target={urllib.parse.quote(package_name)}"
+    try:
+        data = json.loads(urllib.request.urlopen(url, timeout=15).read())
+        return {
+            "name": package_name,
+            "trust_score": data.get("target_trust"),
+            "grade": data.get("target_grade"),
+            "recommendation": data.get("recommendation"),
+            "cve_count": data.get("security", {}).get("cve_count", 0),
+            "license": data.get("security", {}).get("license"),
+            "alternatives": data.get("alternatives", []),
+            "error": None,
+        }
+    except Exception as e:
+        return {
+            "name": package_name,
+            "trust_score": None,
+            "grade": None,
+            "recommendation": None,
+            "cve_count": 0,
+            "license": None,
+            "alternatives": [],
+            "error": str(e),
+        }
+
+
+def scan_file(filepath, api_url=None):
+    """Scan a dependency file and return trust results for all packages."""
+    packages = detect_and_parse(filepath)
+    results = []
+    for pkg in packages:
+        result = check_trust(pkg, api_url)
+        results.append(result)
+    return results

agent_security-1.0.0/agent_security.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: agent-security
+Version: 1.0.0
+Summary: Security scanner for AI agent dependencies. One command to know if your AI stack is safe.
+Home-page: https://nerq.ai
+Author: Nerq
+Author-email: hello@nerq.ai
+License: MIT
+Project-URL: Homepage, https://nerq.ai
+Project-URL: Documentation, https://nerq.ai/start
+Project-URL: Repository, https://github.com/agentic-index/agent-security
+Keywords: ai,agents,security,trust,cve,scanner,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# agent-security
+
+**Know if your AI dependencies are safe. One command.**
+
+```bash
+pip install agent-security
+agent-security scan requirements.txt
+```
+
+Scans all your AI agent dependencies against Nerq's trust database of 204,000+ agents.
+Checks for CVEs, license issues, maintenance status, and overall trust score.
+
+## Output
+
+```
+agent-security scan: requirements.txt
+Scanned 12 dependencies
+
+  OK  langchain: Trust 88 (A), MIT
+  OK  openai: Trust 91 (A+), MIT
+  !!  some-agent: Trust 48 (C), 1 CVE(s), no license
+  !!  risky-tool: Trust 29 (D), 2 CVE(s), AGPL
+
+Summary: 10 trusted, 1 warning(s), 1 critical
+
+Run 'agent-security fix requirements.txt' for improvement recommendations.
+```
+
+## Commands
+
+### scan
+
+```bash
+agent-security scan requirements.txt
+agent-security scan package.json
+agent-security scan pyproject.toml
+agent-security scan requirements.txt --ci  # exits 1 if critical issues
+```
+
+### fix
+
+```bash
+agent-security fix requirements.txt
+```
+
+Shows specific recommendations for each problematic dependency:
+- Alternative packages with higher trust scores
+- CVE details and update suggestions
+
+### check
+
+```bash
+agent-security check langchain
+agent-security check auto-gpt
+```
+
+Check trust for a single package.
+
+### badge
+
+```bash
+agent-security badge my-project
+```
+
+Generates markdown for a Nerq trust badge to add to your README.
+
+### ci
+
+```bash
+agent-security ci
+```
+
+Outputs a ready-to-use GitHub Action YAML for automated trust checking on every PR.
+
+## Supported files
+
+- `requirements.txt` — Python dependencies
+- `package.json` — Node.js dependencies
+- `pyproject.toml` — Python project dependencies
+
+## How it works
+
+agent-security calls the [Nerq API](https://nerq.ai/v1/preflight) for each dependency.
+Every package is scored on:
+
+- **Security** — Known CVEs and vulnerability history
+- **Maintenance** — Update frequency, issue response time
+- **Popularity** — Stars, downloads, community size
+- **License** — SPDX compliance, commercial friendliness
+- **Ecosystem** — Framework compatibility, integration quality
+
+No API key required. Free to use.
+
+## CI Integration
+
+Add to `.github/workflows/trust-check.yml`:
+
+```yaml
+name: Agent Security Check
+on: [push, pull_request]
+
+jobs:
+  trust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install agent-security
+      - run: agent-security scan requirements.txt --ci
+```
+
+## License
+
+MIT

agent_security-1.0.0/agent_security.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+agent_security/__init__.py
+agent_security/cli.py
+agent_security/reporter.py
+agent_security/scanner.py
+agent_security.egg-info/PKG-INFO
+agent_security.egg-info/SOURCES.txt
+agent_security.egg-info/dependency_links.txt
+agent_security.egg-info/entry_points.txt
+agent_security.egg-info/top_level.txt

agent_security-1.0.0/agent_security.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_security-1.0.0/agent_security.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-security = agent_security.cli:main

agent_security-1.0.0/agent_security.egg-info/top_level.txt

@@ -0,0 +1 @@
+agent_security

agent_security-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_security-1.0.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="agent-security",
+    version="1.0.0",
+    description="Security scanner for AI agent dependencies. One command to know if your AI stack is safe.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="Nerq",
+    author_email="hello@nerq.ai",
+    url="https://nerq.ai",
+    project_urls={
+        "Homepage": "https://nerq.ai",
+        "Documentation": "https://nerq.ai/start",
+        "Repository": "https://github.com/agentic-index/agent-security",
+    },
+    packages=find_packages(),
+    python_requires=">=3.8",
+    entry_points={
+        "console_scripts": [
+            "agent-security=agent_security.cli:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Topic :: Security",
+        "Topic :: Software Development :: Quality Assurance",
+    ],
+    keywords=["ai", "agents", "security", "trust", "cve", "scanner", "mcp"],
+    license="MIT",
+)