jiro-automation-layer

name	jiro-automation-layer
description	Jiro's Phase 0: Automated mechanical verification. Runs linters, typecheckers, and static analysis before human review. Catches issues that should never require human attention. Must complete before any code review.
context	inherit
agent	general-purpose
allowed-tools	["Bash(ruff:*)","Bash(mypy:*)","Bash(pylint:*)","Bash(pytest:*)","Bash(npx:nx*)","Bash(npm:*)","Bash(eslint:*)","Bash(tsc:*)","Bash(uv:run*)","Bash(python:*)","Read","Grep","Glob"]

Jiro Automation Layer - Mechanical Issue Detection

Purpose

This is Phase 0 of Jiro's review process. Run ALL automated tools BEFORE human review begins. These tools catch issues that should NEVER escape to human review - unused imports, type errors, lint violations, etc.

Philosophy: Automated tools are infallible for their domain. If ruff says there's an unused import, there is. Don't second-guess tools. Collect ALL findings. Report ALL findings.

---

Detection Protocol

Step 1: Identify Project Type

Look for configuration files to determine which tools to run:

Python Projects:

• pyproject.toml → check for ruff, mypy, pytest config
• setup.py, setup.cfg → legacy Python project
• requirements.txt → Python project

TypeScript/JavaScript Projects:

• tsconfig.json → TypeScript project
• package.json → Node project
• .eslintrc* → ESLint configured

Monorepo:

• nx.json → Nx monorepo (use npx nx run-many)
• pnpm-workspace.yaml → pnpm workspace
• lerna.json → Lerna monorepo

Step 2: Run Applicable Tools

Execute EVERY applicable tool. Do NOT stop on first failure. Collect ALL issues.

---

PYTHON TOOLS

Ruff (Linter + Formatter Check)

# Check for lint issues
ruff check <scope> --output-format=json

# Check for formatting issues
ruff format --check <scope>

Captures:

• Unused imports (F401)
• Undefined names (F821)
• Import order violations
• PEP 8 style violations
• Common bugs and anti-patterns

Mypy (Type Checker)

# Run type checking
mypy <scope> --show-error-codes --no-error-summary

# For monorepos with Nx
npx nx run <project>:typecheck

Captures:

• Type mismatches
• Missing type annotations
• Incompatible types
• Unreachable code

Pylint (Deep Analysis)

# If configured in project
pylint <scope> --output-format=json

Captures:

• Code complexity
• Convention violations
• Refactoring suggestions
• Error-prone patterns

Pytest (Test Status)

# Quick smoke test
pytest <scope> --collect-only -q

# Full test run if scope is limited
pytest <scope> -v --tb=short

Captures:

• Broken tests
• Import errors in test modules
• Fixture issues

---

TYPESCRIPT TOOLS

TypeScript Compiler

# Type checking
tsc --noEmit

# For Nx projects
npx nx run-many -t typecheck

Captures:

• Type errors
• Missing exports
• Incompatible assignments

ESLint

# Lint check
eslint <scope> --format=json

# For Nx projects
npx nx run-many -t lint

Captures:

• Unused variables
• Console statements
• Style violations
• Best practice violations

---

OUTPUT COLLECTION

Structured Output Format

For each tool, produce:

## Tool: [Tool Name]
**Command:** `[exact command run]`
**Exit Code:** [0/1/...]
**Summary:** X errors, Y warnings

### Issues Found:

#### [File Path]
| Line | Code | Message |
|------|------|---------|
| 23 | F401 | `Iterable` imported but unused |
| 30 | F401 | `tensorlogic` imported but unused |

Severity Classification

Classify each issue:

BLOCKING (Must Fix):

• Type errors (mypy errors)
• Undefined names
• Import errors
• Test failures

REQUIRED (Should Fix):

• Unused imports
• Unused variables
• Convention violations

ADVISORY (Consider Fixing):

• Style suggestions
• Complexity warnings
• Refactoring hints

---

EXECUTION CHECKLIST

Execute in this order:

1. Detect project type(s)
2. List all files in scope
3. Run linter (ruff/eslint)
4. Run type checker (mypy/tsc)
5. Run test collection (pytest --collect-only)
6. Aggregate all findings
7. Classify by severity
8. Generate summary report

---

SUMMARY REPORT FORMAT

# Jiro Automation Layer Report

**Scope:** [files/directories reviewed]
**Timestamp:** [ISO timestamp]

## Executive Summary

| Category | Count |
|----------|-------|
| BLOCKING | X |
| REQUIRED | Y |
| ADVISORY | Z |
| **Total** | **N** |

## Verdict

[BLOCKED] - Cannot proceed to human review until BLOCKING issues resolved
[PROCEED] - No blocking issues, ready for human review

## BLOCKING Issues (Must Fix Before Review)

1. **[file:line]** - [code] - [message]
2. ...

## REQUIRED Issues (Will Fail Review)

1. **[file:line]** - [code] - [message]
2. ...

## ADVISORY Issues (Review May Flag)

1. **[file:line]** - [code] - [message]
2. ...

---

## Tool Outputs (Raw)

<details>
<summary>Ruff Output</summary>

[full output]

</details>

<details>
<summary>Mypy Output</summary>

[full output]

</details>

---

INTEGRATION WITH JIRO

This skill produces the input for Jiro's human review phase:

1. If BLOCKED verdict → Stop review, report blocking issues
2. If PROCEED verdict → Pass findings to human review phase
3. Human reviewer should NOT re-check issues caught by automation
4. Human reviewer focuses on: design, architecture, semantics, clarity

The automation layer catches syntax. Jiro catches wisdom.