machin-secure

The split — tool owns the scan, agent owns the judgment

Every finding carries a stable id (sha256(rule|file|line)). The tool never calls an LLM to triage its own false positives — the calling agent does it with the model it already has, and persists the call.

#!/ the whole loop, no API key, no network call to a model provider
./secure --target .                          # JSONL findings on stdout
./secure --target . | jq 'select(.severity=="critical")'
# agent reasons: this one is a Vue prop binding, not a secret
./secure verdict --target . <id> drop --reason "Vue prop binding, not a secret"
# future scans suppress it automatically; --show-all brings it back

Same BYOK split as grepapi's /v1/brief: the tool returns structured data, the operator's own LLM completes the reasoning.

Measured, not asserted

Two independent levers, aimed at two different situations — scope for CI, parallelism for full audits.

Byte-identical findings every way. --diff is the actual fix for CI latency; the engine didn't need to get faster for this case to be fast.

Usage

./build.sh                                              # machin encode + build -> ./secure

./secure --target ./some/repo                           # JSONL findings on stdout
./secure --target ./some/repo --summary                 # one JSON summary object
./secure --target ./some/repo --sarif                   # SARIF 2.1.0 (GitHub Code Scanning)
./secure --target ./some/repo --diff                    # only working-tree-changed files
./secure --target ./some/repo --diff-base origin/main   # only files changed vs a base ref (PR CI)
./secure --target ./some/repo --workers 16              # parallel full-audit (default: 8)
./secure --target ./some/repo --hart                    # guidance for the agent's own hart report

./secure verdict --target . <id> drop --reason "..."   # persist the agent's judgment
./secure verdict --target . --stdin                     # batch verdicts via JSON Lines

Exit codes: 0 clean · 1 error · 2 high/critical findings present.

1,000 CWE-tagged detections across 25 languages

rules.json is plain data, read fresh from disk every run — extend it without recompiling. The rule pack is the actual product; the engine is interchangeable.

PythonJS/TSVueGoRustC/C++C#Java/KotlinRubyShellSwiftPHPYAMLTerraformDockerfileXMLTOML.propertiesplistINIrequirements.txtGemfileJSON

CI / GitHub Code Scanning

--sarif emits a SARIF 2.1.0 report (validated against the official schema) that GitHub's Security tab, VS Code, and any SARIF consumer read directly. There's a reusable GitHub Action — drop this into any repo:

# .github/workflows/machin-secure.yml
name: machin-secure
on: [push, pull_request]
permissions:
  contents: read
  security-events: write   # required to upload SARIF
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: javimosch/machin-secure@v2
        with:
          target: '.'
      - uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: machin-secure.sarif
          category: machin-secure

The action exits 0 whether or not findings exist (so the SARIF upload always runs); severity gating is left to GitHub code-scanning settings.

What it is NOT (on purpose)

Built with

machin / MFL — a language optimized for the AI agent writing it. The scanner is ~500 lines of MFL, compiled to a single ~88 KB static binary. Read the vision & north star →