skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
aurite-ai/agent-verifier50 installs

verify-language

Language-specific verification for Python, TypeScript/JavaScript, and Go. Checks type safety, language idioms, and best practices. Use when asked to "verify language", "check types", or for language-specific checks.

How do I install this agent skill?

npx skills add https://github.com/aurite-ai/agent-verifier --skill verify-language
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill is a static analysis tool designed to verify code quality, type safety, and language-specific best practices for Python, TypeScript, and Go. It operates by instructing the agent to review project configuration and source code files locally, without performing network operations, executing code, or modifying the system.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

Language-Specific Verification

Purpose

Verify code against language-specific best practices and idioms for Python, TypeScript/JavaScript, and Go. No telemetry or network calls of its own.

When to Use

Trigger this skill when the user asks to:

  • "verify agent language"
  • "verify language"
  • "check types"
  • "check Python/TypeScript/Go code"

This skill is also auto-invoked by the main verification orchestrator based on detected language.

Note: For full verification including security, patterns, and quality checks, tell the user to say "verify agent".

Process

Step 1: Detect Language

Identify the primary language by checking:

IndicatorLanguage
pyproject.toml, requirements.txt, setup.pyPython
package.json, tsconfig.jsonTypeScript/JavaScript
go.mod, go.sumGo
Cargo.tomlRust

Also check file extensions in src/ or project root:

  • .py → Python
  • .ts, .tsx, .js, .jsx → TypeScript/JavaScript
  • .go → Go
  • .rs → Rust

Step 2: Run Language-Specific Checks

Apply checks based on detected language. Each section below is only applicable for its language.


Python Checks

[PATTERN] Type Hints on Public Functions

Flag any def function in public scope (no leading _) that has parameters without type annotations.

Examples:

# ⚠️ Warning - Missing type hints
def get_user(user_id):
    return db.find_user(user_id)

def process_items(items, filter_fn):
    return [filter_fn(item) for item in items]

# ✅ Pass - Has type hints
def get_user(user_id: int) -> User:
    return db.find_user(user_id)

def process_items(items: list[Item], filter_fn: Callable[[Item], bool]) -> list[Item]:
    return [filter_fn(item) for item in items]

Scope:

  • Public functions (no leading _)
  • Class methods (except __init__ can skip return type)
  • Module-level functions

Severity: ⚠️ Warning


[HEURISTIC] Docstrings

Check for missing docstrings:

LocationRequirement
ModuleTop-level docstring explaining purpose
ClassDocstring explaining class responsibility
Public functionDocstring explaining args, returns, raises

Examples:

# ⚠️ Warning - Missing docstrings
class UserService:
    def get_user(self, user_id: int) -> User:
        return self.db.find(user_id)

# ✅ Pass - Documented
class UserService:
    """Service for user-related operations."""
    
    def get_user(self, user_id: int) -> User:
        """
        Retrieve a user by ID.
        
        Args:
            user_id: The unique identifier of the user
            
        Returns:
            User object if found
            
        Raises:
            UserNotFoundError: If user doesn't exist
        """
        return self.db.find(user_id)

Severity: ⚠️ Warning


[PATTERN] Requirements Pinning

Check requirements.txt and pyproject.toml dependencies:

PatternSeverity
package>=1.0❌ Issue
package>1.0❌ Issue
package (no version)❌ Issue
package==1.0.0✅ Pass
package~=1.0✅ Pass

In pyproject.toml:

# ❌ Issue
[project]
dependencies = [
    "langchain>=0.1.0",
    "openai",
]

# ✅ Pass
[project]
dependencies = [
    "langchain==0.1.0",
    "openai==1.12.0",
]

Severity: ❌ Issue


[HEURISTIC] Python Idioms

Check for non-idiomatic patterns:

Anti-patternIdiomatic
if len(list) > 0:if list:
if x == True:if x:
list = list + [item]list.append(item)
for i in range(len(list)):for item in list: or enumerate()
dict.keys() iterationDirect dict iteration

Severity: ⚠️ Warning


TypeScript/JavaScript Checks

[PATTERN] Strict Mode

Check tsconfig.json for strict type checking:

// ❌ Issue - Not strict
{
  "compilerOptions": {
    "strict": false
  }
}

// ❌ Issue - Strict not set
{
  "compilerOptions": {
    "target": "ES2020"
  }
}

// ✅ Pass
{
  "compilerOptions": {
    "strict": true
  }
}

Severity: ❌ Issue (if strict is false or absent)


[PATTERN] No any Types

Flag unqualified : any type annotations:

// ⚠️ Warning
function process(data: any): any {
    return data.value;
}

const items: any[] = [];

// ✅ Pass - Specific types
function process(data: UserData): ProcessedData {
    return { value: data.value };
}

// ✅ Pass - Explicit unknown with narrowing
function process(data: unknown): ProcessedData {
    if (isUserData(data)) {
        return { value: data.value };
    }
    throw new Error("Invalid data");
}

Severity: ⚠️ Warning


[HEURISTIC] Async/Await Error Handling

Check that async functions handle errors:

// ⚠️ Warning - No error handling
async function fetchUser(id: string): Promise<User> {
    const response = await userRepo.load(id);
    return response;
}

// ✅ Pass - Has error handling
async function fetchUser(id: string): Promise<User> {
    try {
        const response = await userRepo.load(id);
        return response;
    } catch (error) {
        logger.error("Failed to fetch user", { id, error });
        throw new UserFetchError(id, error);
    }
}

Severity: ⚠️ Warning


[HEURISTIC] Promise Handling

Check for common Promise anti-patterns:

Anti-patternIssue
Missing .catch()Unhandled rejection
new Promise() with async executorAnti-pattern
Fire-and-forget promisesNo await, no handling
// ⚠️ Warning - No catch
fetchData().then(process);

// ⚠️ Warning - Async executor
new Promise(async (resolve) => {
    const data = await fetchData();
    resolve(data);
});

// ✅ Pass
fetchData().then(process).catch(handleError);

// ✅ Pass - Using async/await
const data = await fetchData();
process(data);

Severity: ⚠️ Warning


Go Checks

[PATTERN] No Ignored Errors

Flag any _ = assignments where the right-hand side returns error:

// ❌ Issue - Ignored error
_ = file.Close()
_ = json.Unmarshal(data, &result)
result, _ := db.Query(sql)

// ✅ Pass - Error handled
if err := file.Close(); err != nil {
    log.Printf("failed to close file: %v", err)
}

result, err := db.Query(sql)
if err != nil {
    return nil, fmt.Errorf("query failed: %w", err)
}

Severity: ❌ Issue


[HEURISTIC] Context Propagation

Check that context.Context is passed through call chains:

// ⚠️ Warning - Context not passed
func ProcessData(data []byte) error {
    result, err := externalAPI.Call(data)  // No context
    return err
}

// ✅ Pass - Context propagated
func ProcessData(ctx context.Context, data []byte) error {
    result, err := externalAPI.Call(ctx, data)
    return err
}

Check for:

  • HTTP handlers that don't use r.Context()
  • Functions that call external services without context
  • Long-running operations without context cancellation support

Severity: ⚠️ Warning


[HEURISTIC] Proper Package Structure

Check Go project structure:

IssueDescription
package main with many filesShould split into packages
Circular importsPackage A imports B, B imports A
Internal packages exposedInternal code in public packages
Missing internal/Shared code that shouldn't be public

Severity: ⚠️ Warning


[HEURISTIC] Go Idioms

Check for non-idiomatic patterns:

Anti-patternIdiomatic
if err != nil { return err } repeatedlyConsider helper or wrap
Naked returns in long functionsExplicit returns
interface{} without type assertionsUse generics or specific types
Getters named GetX()Just X()

Severity: ⚠️ Warning


Step 3: Generate Report

# Language Verification Report

**Project:** [name or path]
**Date:** [current date]
**Language detected:** [Python | TypeScript | JavaScript | Go]
**Files analyzed:** [count]

## Summary

✅ X checks passed | ⚠️ Y warnings | ❌ Z issues

## Type Safety

- [x] Types properly defined
- [ ] ⚠️ Missing type hints at `[file:line]`
- [ ] ❌ Strict mode not enabled in `tsconfig.json`

## Language Idioms

- [x] Code follows language best practices
- [ ] ⚠️ Non-idiomatic pattern at `[file:line]`

## Error Handling

- [x] Errors properly handled
- [ ] ❌ Ignored error at `[file:line]`

## Findings

> `[P]` = pattern-matched · `[H]` = heuristic

### ✅ Passing
- `[P]` [Check]: [confirmation]

### ⚠️ Warnings
- `[P|H]` [Check]: [description]
  - **Location:** [file:line]
  - **Language rule:** [which idiom/pattern]
  - **Suggestion:** [how to fix]

### ❌ Issues
- `[P]` [Check]: [description]
  - **Location:** [file:line]
  - **Rule:** [which rule violated]
  - **Fix:** [specific remediation]

## Language-Specific Recommendations

### Python
1. Add type hints to public functions
2. Include docstrings for classes and functions

### TypeScript
1. Enable strict mode in tsconfig.json
2. Replace `any` with specific types

### Go
1. Handle all returned errors
2. Propagate context through call chains

For full verification including security, patterns, and quality checks, say "verify agent".

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/aurite-ai/agent-verifier/verify-language">View verify-language on skillZs</a>