TI = 1 / (n_deps × side_effects)

Score = max(0, 10 - soma_penalidades)

Score Final = 0.3*Architecture + 0.25*Hooks + 0.2*Electron + 0.15*TypeScript + 0.1*Apollo

{
  "summary": {
    "total_files": 72,
    "overall_score": 7.2,
    "health_level": "Bom",
    "critical_issues": 5,
    "high_issues": 12,
    "medium_issues": 8,
    "low_issues": 0,
    "analysis_duration_ms": 15000
  },
  "categories": {
    "architecture": { "score": 7.0, "issues": 3, "top_issues": ["FRONT-ARCH-01", "FRONT-ARCH-05"] },
    "hooks": { "score": 6.0, "issues": 8, "top_issues": ["FRONT-HOOK-02"] },
    "electron": { "score": 8.5, "issues": 2, "top_issues": ["FRONT-ELEC-01"] },
    "typescript": { "score": 7.5, "issues": 5, "top_issues": ["FRONT-TS-01"] },
    "apollo": { "score": 8.0, "issues": 0, "top_issues": [] },
    "tailwind": { "score": 9.0, "issues": 0, "top_issues": [] }
  },
  "files": [
    {
      "path": "src/components/UserForm.tsx",
      "score": 6.5,
      "category_scores": {
        "architecture": 8.0,
        "hooks": 5.0,
        "typescript": 7.0
      },
      "issues": [
        {
          "id": "FRONT-HOOK-02",
          "category": "hooks",
          "severity": "HIGH",
          "line": 45,
          "msg": "useEffect com dependências faltando",
          "code": "useEffect(() => { fetchData(); }, [])",
          "why_it_matters": "Dependências faltantes podem causar bugs de stale closure",
          "recommended_fix": "Adicionar fetchData às dependências: [fetchData]"
        }
      ],
      "smells": ["FRONT-HIGH-01"],
      "recommendation": "Adicionar fetchData às dependências do useEffect"
    }
  ],
  "aggregate_issues": {
    "FRONT-HOOK-02": { "count": 8, "severity": "HIGH", "description": "Dependencies Array Missing" },
    "FRONT-ARCH-01": { "count": 2, "severity": "CRITICAL", "description": "Framework Leakage" },
    "FRONT-TS-01": { "count": 3, "severity": "CRITICAL", "description": "Any Type" }
  },
  "metadata": {
    "analyzer_version": "1.0.0",
    "timestamp": "2026-02-05T10:00:00Z",
    "mode": "health",
    "constraints_applied": false,
    "project_type": "electron",
    "stack_features": ["apollo", "tailwind"]
  }
}

// zord-ignore FRONT-HOOK-02
useEffect(() => { fetchData(); }, []);

src/legacy/**/*.ts
**/generated/**/*.ts
src/legacy/utils.ts: [FRONT-TS-01, FRONT-TS-03]

{
  "suppressions": [
    {
      "rule": "FRONT-HOOK-02",
      "file": "src/components/UserProfile.tsx",
      "line": 45,
      "reason": "Legacy API constraint",
      "expires": "2026-12-31"
    }
  ]
}

// BAD - Prop drilling profundo
function App() {
  const user = { name: 'John' };
  return <A user={user} />;
}
function A({ user }) { return <B user={user} />; }
function B({ user }) { return <C user={user} />; }
function C({ user }) { return <D user={user} />; }
function D({ user }) { return <span>{user.name}</span>; }

// GOOD - Context API
const UserContext = createContext<User | null>(null);
function App() {
  return (
    <UserContext.Provider value={{ name: 'John' }}>
      <A />
    </UserContext.Provider>
  );
}
function D() {
  const user = useContext(UserContext);
  return <span>{user?.name}</span>;
}

// BAD - Effect para computação derivada
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [displayName, setDisplayName] = useState('');
  useEffect(() => {
    setDisplayName(user?.firstName + ' ' + user?.lastName);
  }, [user]);
  return <div>{displayName}</div>;
}

// GOOD - Estado derivado computado
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const displayName = `${user?.firstName} ${user?.lastName}`;
  return <div>{displayName}</div>;
}

// BAD - Missing cleanup
function Timer() {
  const [seconds, setSeconds] = useState(0);
  useEffect(() => {
    const intervalId = setInterval(() => {
      setSeconds(s => s + 1);
    }, 1000);
    // Missing cleanup - memory leak
  }, []);
  return <div>Timer: {seconds}s</div>;
}

// GOOD - Cleanup function
function Timer() {
  const [seconds, setSeconds] = useState(0);
  useEffect(() => {
    const intervalId = setInterval(() => {
      setSeconds(s => s + 1);
    }, 1000);
    return () => clearInterval(intervalId);
  }, []);
  return <div>Timer: {seconds}s</div>;
}

// BAD - ipcRenderer exposto diretamente
mainWindow = new BrowserWindow({
  webPreferences: {
    nodeIntegration: true,        // PERIGO
    contextIsolation: false,      // PERIGO
  }
});

// GOOD - contextBridge com API mínima
mainWindow = new BrowserWindow({
  webPreferences: {
    nodeIntegration: false,
    contextIsolation: true,
    preload: path.join(__dirname, 'preload.js')
  }
});

// preload.js
const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('electronAPI', {
  readFile: (filePath) => ipcRenderer.invoke('fs:readFile', filePath),
});

// BAD - Business logic em componente
const OrderSummary: React.FC = () => {
  const [items, setItems] = useState([]);
  const [total, setTotal] = useState(0);
  useEffect(() => {
    const calculatedTotal = items.reduce((sum, item) => {
      if (item.isOnSale) return sum + (item.price * 0.8);
      return sum + item.price;
    }, 0);
    setTotal(calculatedTotal);
  }, [items]);
  return <div>Total: ${total}</div>;
};

// GOOD - Logic em use case
const OrderSummary: React.FC = () => {
  const { items, total } = useCalculateOrderTotal();
  return <div>Total: ${total}</div>;
};

interface SkillInput {
  files: string[];
  mode: "health" | "error";
  layer: "Domain" | "Infrastructure" | "All";
  categories: string[];
  scope: "full" | "module:<path>" | "changed";
  project_type: "electron" | "react" | "nextjs";
  stack_features: string[];
}

interface AnalysisOutput {
  summary: {
    total_files: number;
    overall_score: number;
    health_level: "Crítico" | "Ruim" | "Regular" | "Bom" | "Excelente";
    critical_issues: number;
    high_issues: number;
    medium_issues: number;
    low_issues: number;
    analysis_duration_ms: number;
  };
  categories: {
    [key: string]: { score: number; issues: number; top_issues: string[] };
  };
  files: FileAnalysis[];
  aggregate_issues: { [ruleId: string]: AggregateIssue };
  metadata: {
    analyzer_version: string;
    timestamp: string;
    mode: string;
    constraints_applied: boolean;
  };
}