Smar 49 create ai conventions checker git action

script/violations/BadCodeQuality.ts

@@ -0,0 +1,56 @@
+/**
+ * Violation: Code quality issues - uses `any`, poor error handling.
+ * 
+ * Convention violations:
+ * - Obey .eslintrc.cjs; avoid `any` types
+ * - Use proper error handling with consola.error()
+ * - Exit with process.exit(1) on fatal errors
+ * - Provide meaningful error messages
+ * 
+ * This file violates by using `any` types and not handling errors properly.
+ */
+
+import { consola } from 'consola'
+
+// Violation: Uses `any` type instead of proper typing
+function processData(data: any) {
+  // Violation: Should use proper types (unknown with type narrowing, or specific interface)
+  return data.value
+}
+
+// Violation: Uses `any` for error handling
+function handleError(error: any) {
+  // Violation: Should use proper error type (Error | unknown with narrowing)
+  console.log(error.message) // Violation: Uses console.log instead of consola
+}
+
+// Violation: Doesn't exit with process.exit(1) on fatal errors
+function fatalOperation() {
+  try {
+    // Some operation that might fail
+    throw new Error('Fatal error')
+  } catch (error) {
+    // Violation: Should use consola.error() and process.exit(1)
+    console.error('Error occurred') // Violation: Uses console.error instead of consola.error
+    // Missing: process.exit(1)
+  }
+}
+
+// Violation: Poor error messages
+function badFunction() {
+  try {
+    // Operation that can fail
+    JSON.parse('invalid json') // This will throw
+  } catch {
+    // Violation: No error message, should provide meaningful message
+    throw new Error('Error') // Violation: Generic error message
+  }
+}
+
+// Violation: Uses `any` for function parameters
+function processContract(contract: any) {
+  // Violation: Should use proper type (e.g., from typechain or viem)
+  return contract.address
+}
+
+export { processData, handleError, fatalOperation, badFunction, processContract }

script/violations/BadDRY.ts

@@ -0,0 +1,61 @@
+/**
+ * Violation: Duplicates code that should use existing helpers.
+ * 
+ * Convention violation: Check existing helpers in:
+ * - script/common/
+ * - script/utils/
+ * - script/demoScripts/utils/
+ * 
+ * Key helpers: deploymentHelpers.ts, demoScriptHelpers.ts, script/common/types.ts
+ * 
+ * This file violates by re-implementing logic that exists in helpers.
+ */
+
+import { consola } from 'consola'
+import { createPublicClient, http, getAddress, type Address } from 'viem'
+// Violation: Should import getDeployments from '../utils/deploymentHelpers'
+// Violation: Should import getViemChainForNetworkName from '../utils/viemScriptHelpers'
+
+// Violation: Re-implements network config reading that exists in viemScriptHelpers.getViemChainForNetworkName
+function getNetworkConfig(networkName: string) {
+  // Violation: Should use getViemChainForNetworkName from viemScriptHelpers instead
+  const networks = require('../../config/networks.json')
+  return networks[networkName]
+}
+
+// Violation: Re-implements deployment address reading that exists in deploymentHelpers.getDeployments
+function getDeploymentAddress(network: string, contractName: string) {
+  // Violation: Should use getDeployments from deploymentHelpers instead
+  const deployments = require(`../../deployments/${network}.json`)
+  return deployments[contractName]
+}
+
+// Violation: Re-implements address validation that getAddress from viem already provides
+function validateAddress(address: string): Address {
+  // Violation: Should use getAddress from viem (already imported but re-implemented)
+  if (!address.startsWith('0x') || address.length !== 42) {
+    throw new Error('Invalid address')
+  }
+  return address as Address
+}
+
+// Violation: Re-implements client creation pattern that exists in demoScriptHelpers
+function createClient(networkName: string) {
+  // Violation: Should use helpers from demoScriptHelpers or viemScriptHelpers instead
+  const network = getNetworkConfig(networkName)
+  return createPublicClient({
+    transport: http(network.rpcUrl),
+  })
+}
+
+export async function badFunction() {
+  // Violation: Uses duplicated logic instead of helpers
+  // Should use: getDeployments('mainnet') from deploymentHelpers
+  // Should use: getViemChainForNetworkName('mainnet') from viemScriptHelpers
+  const network = getNetworkConfig('mainnet')
+  const address = getDeploymentAddress('mainnet', 'LiFiDiamond')
+  const client = createClient('mainnet')
+  const validated = validateAddress(address) // Should use getAddress(address) directly
+
+  consola.info(`Using duplicated logic instead of helpers: ${validated}`)
+}

script/violations/BadEthersUsage.ts

@@ -0,0 +1,50 @@
+/**
+ * Violation: Uses deprecated ethers.js helpers instead of viem.
+ * 
+ * Convention violation: Contract interactions MUST use viem.
+ * DO NOT use deprecated ethers.js helpers like:
+ * - getProvider
+ * - getWalletFromPrivateKeyInDotEnv
+ * - ethers sendTransaction
+ * - ensureBalanceAndAllowanceToDiamond
+ * 
+ * Use TypeChain types from typechain/ directory (e.g., ILiFi.BridgeDataStruct)
+ * 
+ * This file violates by using ethers.js for contract interactions.
+ */
+
+import { ethers } from 'ethers'
+import { consola } from 'consola'
+
+// Violation: Uses deprecated ethers.js getProvider helper
+// Should use viem's createPublicClient instead
+function getProvider(network: string) {
+  return ethers.getDefaultProvider(network)
+}
+
+// Violation: Uses deprecated ethers.js getWalletFromPrivateKeyInDotEnv pattern
+// Should use viem's privateKeyToAccount instead
+function getWalletFromPrivateKeyInDotEnv() {
+  const privateKey = process.env.PRIVATE_KEY || ''
+  return new ethers.Wallet(privateKey, getProvider('mainnet'))
+}
+
+// Violation: Uses ethers.js sendTransaction instead of viem
+async function sendTransaction() {
+  const wallet = getWalletFromPrivateKeyInDotEnv()
+  const contract = new ethers.Contract('0x1234567890123456789012345678901234567890', ['function transfer()'], wallet)
+
+  // Violation: Should use viem's writeContract or sendTransaction
+  const tx = await contract.transfer()
+  await tx.wait()
+}
+
+// Violation: Uses deprecated ensureBalanceAndAllowanceToDiamond pattern
+// Should use viem-based helpers from deploymentHelpers or demoScriptHelpers
+async function ensureBalanceAndAllowanceToDiamond(token: string, amount: string) {
+  const wallet = getWalletFromPrivateKeyInDotEnv()
+  const tokenContract = new ethers.Contract(token, ['function approve(address,uint256)'], wallet)
+  await tokenContract.approve('0x...', amount)
+}
+
+export { getProvider, getWalletFromPrivateKeyInDotEnv, sendTransaction, ensureBalanceAndAllowanceToDiamond }

script/violations/BadImportOrder.ts

@@ -0,0 +1,34 @@
+/**
+ * Violation: Imports are in incorrect order.
+ * 
+ * Convention violation: Imports MUST be ordered as:
+ * 1. External libs (viem, consola, citty, dotenv)
+ * 2. TypeChain types (typechain/)
+ * 3. Config files
+ * 4. Internal utils/helpers
+ * Use `type` imports for types-only
+ * 
+ * This file violates by importing internal utils before external libs,
+ * and config before TypeChain types.
+ */
+
+// Violation: Internal utils imported FIRST (should be LAST, after external libs, TypeChain, config)
+import { getDeployments } from '../utils/deploymentHelpers'
+import { getViemChainForNetworkName } from '../utils/viemScriptHelpers'
+import type { SupportedChain } from '../common/types'
+
+// Violation: Config imported BEFORE TypeChain types (should be: external libs -> TypeChain -> config -> utils)
+import networksConfig from '../../config/networks.json'
+
+// Violation: External libs imported AFTER internal utils and config (should be FIRST)
+import { consola } from 'consola'
+import { createPublicClient, http, type Address } from 'viem'
+
+// Violation: TypeChain types imported LAST (should be SECOND, right after external libs)
+import type { ILiFi } from '../../../typechain'
+
+// Violation: Should use `type` import for types-only (SupportedChain, Address, ILiFi)
+export async function badFunction() {
+  const deployments = getDeployments('mainnet')
+  consola.info('Bad import order example')
+}

script/violations/BadSafeDecode.ts

@@ -0,0 +1,69 @@
+/**
+ * Violation: Safe decode script doesn't use formatDecodedTxDataForDisplay.
+ * 
+ * Convention violation: Human-readable decoded Safe/timelock transaction data
+ * MUST be produced via formatDecodedTxDataForDisplay(data, context) from
+ * safe-decode-utils.ts.
+ * 
+ * Scripts showing Safe or timelock calldata MUST call this function instead
+ * of duplicating decode/format logic.
+ * 
+ * Pass { chainId: number, network: string } context.
+ * Decode and formatters live in safe-decode-utils.ts: decodeTransactionData,
+ * display helpers (getTargetName, getTargetSuffix), formatters
+ * (formatDiamondCutSummary, formatTimelockScheduleBatch, etc.).
+ * 
+ * This file violates by implementing its own decode/format logic.
+ */
+
+import { consola } from 'consola'
+import { decodeFunctionData, parseAbi, type Hex } from 'viem'
+// Violation: Should import formatDecodedTxDataForDisplay from '../deploy/safe/safe-decode-utils'
+
+// Violation: Implements custom decode logic instead of using formatDecodedTxDataForDisplay
+function decodeSafeTransaction(data: Hex) {
+  // Violation: Should use formatDecodedTxDataForDisplay from safe-decode-utils.ts instead
+  const abi = parseAbi(['function diamondCut((address,uint8,bytes4[])[],address,bytes)'])
+
+  try {
+    const decoded = decodeFunctionData({
+      abi,
+      data,
+    })
+
+    // Violation: Custom formatting instead of using formatDecodedTxDataForDisplay
+    consola.info('Decoded transaction:')
+    consola.info(`Function: ${decoded.functionName}`)
+    consola.info(`Args: ${JSON.stringify(decoded.args)}`)
+
+    return decoded
+  } catch (error) {
+    // Violation: Custom error handling instead of using shared formatter
+    consola.error('Failed to decode transaction')
+    throw error
+  }
+}
+
+// Violation: Implements custom diamond cut formatting
+// Should use formatDiamondCutSummary from safe-decode-utils.ts instead
+function formatDiamondCut(decoded: unknown) {
+  consola.info('Diamond Cut Summary:')
+  // Violation: Custom formatting logic instead of using formatDiamondCutSummary
+  // Custom formatting logic...
+}
+
+// Violation: Implements custom decodeTransactionData logic
+// Should use decodeTransactionData from safe-decode-utils.ts instead
+function decodeTransactionData(data: Hex) {
+  return decodeSafeTransaction(data)
+}
+
+export function processSafeTransaction(data: Hex, chainId: number, network: string) {
+  // Violation: Should call formatDecodedTxDataForDisplay(data, { chainId, network })
+  // Instead of implementing custom decode/format logic
+  const decoded = decodeSafeTransaction(data)
+  formatDiamondCut(decoded)
+
+  // Violation: Should use formatDecodedTxDataForDisplay instead:
+  // formatDecodedTxDataForDisplay(data, { chainId, network })
+}

script/violations/BadTypeDefinition.ts

@@ -0,0 +1,51 @@
+/**
+ * Violation: Type definitions don't follow naming conventions.
+ * 
+ * Convention violations:
+ * - Interfaces MUST start with `I` prefix (e.g., INetwork, ITransferResult) - hard requirement enforced by ESLint
+ * - Enums MUST use PascalCase with `Enum` suffix (e.g., EnvironmentEnum)
+ * - Type aliases use PascalCase without prefix (e.g., SupportedChain, HexString)
+ * - Always check existing types before defining new ones: Search in order: TypeChain types, viem types, script/common/types.ts
+ * - Reuse existing types over defining duplicates
+ * 
+ * This file violates by defining interfaces without `I` prefix and enums without `Enum` suffix.
+ */
+
+import { consola } from 'consola'
+// Violation: Should check existing types in script/common/types.ts first (INetwork already exists)
+// Violation: Should reuse SupportedChain from script/common/types.ts instead of defining new type
+
+// Violation: Interface doesn't start with `I` prefix (ESLint should catch this)
+export interface Network {
+  name: string
+  chainId: number
+}
+
+// Violation: Interface doesn't start with `I` prefix (ESLint should catch this)
+export interface TransferResult {
+  success: boolean
+  txHash: string
+}
+
+// Violation: Enum doesn't have `Enum` suffix (should be EnvironmentEnum)
+export enum Environment {
+  staging = 'staging',
+  production = 'production',
+}
+
+// Violation: Enum doesn't have `Enum` suffix (should be StatusEnum)
+export enum Status {
+  pending = 'pending',
+  completed = 'completed',
+}
+
+// Violation: Type alias uses lowercase (should be PascalCase: NetworkName)
+export type networkName = string
+
+// Violation: Type alias uses camelCase (should be PascalCase: TransferHash)
+export type transferHash = string
+
+// Violation: Should use existing INetwork from script/common/types.ts instead of defining duplicate
+export function badFunction(network: Network, result: TransferResult, env: Environment, status: Status) {
+  consola.info(`Network: ${network.name}, Result: ${result.success}, Env: ${env}, Status: ${status}`)
+}