Scanning project...
✓ Found Move.toml
✓ Detected 8 .move files in sources/
✓ Found 3 test modules

Analyzing against Move Book standards...
✓ Naming conventions (15/18 rules)
⚠ Module structure (12/14 rules)
✗ Testing coverage (6/12 rules)
✓ Documentation (18/20 rules)

Critical Issues (must fix):
  - Missing unit tests for transfer_ownership()
  - Public function lacks access control check
  - Resource not properly moved in withdraw()

Recommended Improvements:
  - Add doc comments to 3 public functions
  - Consider extracting validation logic
  - Use const for magic numbers

Enhancements:
  - Could optimize storage with packed fields
  - Generic type parameter would improve reusability

Review my Move package for code quality issues

Check my Move code for security issues and proper
resource safety patterns

Quick quality check before I commit. Focus on critical
issues only.

You flagged "public function lacks access control".
Can you explain why this is critical and show me how to fix it?

// ✓ Good
module my_package::token_manager {
    const MAX_SUPPLY: u64 = 1_000_000;

    struct TokenMetadata has key {
        total_supply: u64,
    }

    public fun get_total_supply(): u64 { ... }
}

// ✗ Issues found
module my_package::TokenManager {  // Should be snake_case
    const maxSupply: u64 = 1_000_000;  // Should be SCREAMING_SNAKE_CASE

    struct token_metadata has key {  // Should be PascalCase
        TotalSupply: u64,  // Should be snake_case
    }

    public fun GetTotalSupply(): u64 { ... }  // Should be snake_case
}

// ✗ Missing tests
public fun transfer_ownership(new_owner: address) { ... }

// ✓ Well-tested
public fun transfer_ownership(new_owner: address) { ... }

#[test]
fun test_transfer_ownership_success() { ... }

#[test]
#[expected_failure(abort_code = E_NOT_OWNER)]
fun test_transfer_ownership_unauthorized() { ... }

#[test]
#[expected_failure(abort_code = E_INVALID_ADDRESS)]
fun test_transfer_ownership_zero_address() { ... }

// ✗ Resource leaked
public fun withdraw(account: &signer): Token {
    let token = borrow_global<Token>(@owner);
    token  // Error: can't copy resource
}

// ✓ Proper move
public fun withdraw(account: &signer): Token
    acquires Token
{
    move_from<Token>(signer::address_of(account))
}

// ✗ Missing authorization
public fun set_admin(new_admin: address) {
    // Anyone can call this!
    borrow_global_mut<AdminCap>(@owner).admin = new_admin;
}

// ✓ Proper capability check
public fun set_admin(
    admin_cap: &AdminCap,
    new_admin: address
) acquires AdminCap {
    assert!(admin_cap.is_valid, E_INVALID_ADMIN);
    borrow_global_mut<AdminCap>(@owner).admin = new_admin;
}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔴 CRITICAL (3 issues)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Missing Access Control
   Location: token_manager.move:45
   Function: mint_tokens()
   Issue: Public function allows anyone to mint
   Fix: Add AdminCap requirement

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🟡 RECOMMENDED (5 improvements)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4. Missing Documentation
   Location: utils.move:12
   Function: calculate_reward()
   Suggestion: Add doc comment explaining formula

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔵 ENHANCEMENTS (8 opportunities)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

9. Gas Optimization
   Location: batch.move:67
   Opportunity: Use vector operations instead of loop
   Impact: 30% gas reduction

User: "Why is using references more gas-efficient?"

Skill: "In Move, passing by reference (&T or &mut T) avoids copying
the value, which saves both computation and storage costs. For large
structs, this can significantly reduce gas:

Example:
  fun process_token(token: &Token) { ... }  // Gas: ~100 units
  vs.
  fun process_token(token: Token) { ... }   // Gas: ~500 units

The difference grows with struct size. Always prefer references
unless you need to move ownership."

Issue: Missing doc comment on public function

Offer: Would you like me to add a template doc comment?

Generated:
/// Transfers tokens from one account to another
///
/// # Arguments
/// * `from` - Source account signer
/// * `to` - Destination address
/// * `amount` - Number of tokens to transfer
///
/// # Aborts
/// * `E_INSUFFICIENT_BALANCE` if from lacks funds
/// * `E_INVALID_RECIPIENT` if to is zero address
public fun transfer(from: &signer, to: address, amount: u64) { ... }