Membina Penyemak Kod AI Tempatan dengan ClientAI dan Ollama

Pernah mahu penyemak kod berkuasa AI anda sendiri yang berjalan sepenuhnya pada mesin tempatan anda? Dalam tutorial dua bahagian ini, kami akan membinanya dengan tepat menggunakan ClientAI dan Ollama.

Pembantu kami akan menganalisis struktur kod Python, mengenal pasti isu yang berpotensi dan mencadangkan penambahbaikan — semuanya sambil memastikan kod anda peribadi dan selamat.

Untuk dokumen ClientAI lihat di sini dan untuk Github Repo, di sini.

Indeks Siri

• Bahagian 1: Pengenalan, Persediaan, Penciptaan Alat (anda berada di sini)
• Bahagian 2: Membina Pembantu dan Antara Muka Baris Perintah

Gambaran Keseluruhan Projek

Pembantu analisis kod kami akan berupaya:

• Menganalisis struktur dan kerumitan kod
• Mengenal pasti isu gaya dan masalah yang berpotensi
• Menjana cadangan dokumentasi
• Menyediakan pengesyoran penambahbaikan yang boleh diambil tindakan

Semua ini akan dijalankan secara setempat pada mesin anda, memberikan anda kuasa semakan kod dibantu AI sambil mengekalkan privasi lengkap kod anda.

Sediakan Persekitaran Kita

Pertama, buat direktori baharu untuk projek anda:

mkdir local_task_planner
cd local_task_planner

Pasang ClientAI dengan sokongan Ollama:

pip install clientai[ollama]

Pastikan anda telah memasang Ollama pada sistem anda. Anda boleh mendapatkannya dari tapak web Ollama.

Sekarang mari buat fail yang akan kita tulis kodnya:

touch code_analyzer.py

Dan mulakan dengan import teras kami:

import ast
import json
import logging
import re
from dataclasses import dataclass
from typing import List
from clientai import ClientAI
from clientai.agent import (
    Agent,
    ToolConfig,
    act,
    observe,
    run,
    synthesize,
    think,
)
from clientai.ollama import OllamaManager, OllamaServerConfig

Setiap komponen ini memainkan peranan penting:

• ast: Membantu kami memahami kod Python dengan menghuraikannya ke dalam struktur pokok
• ClientAI: Menyediakan rangka kerja AI kami
• Pelbagai modul utiliti untuk pengendalian data dan padanan corak

Menstrukturkan Keputusan Analisis Kami

Apabila menganalisis kod, kami memerlukan cara yang bersih untuk mengatur penemuan kami. Begini cara kami akan menstrukturkan keputusan kami:

@dataclass
class CodeAnalysisResult:
    """Results from code analysis."""
    complexity: int
    functions: List[str]
    classes: List[str]
    imports: List[str]
    issues: List[str]

Anggap ini sebagai kad laporan kami untuk analisis kod:

• Skor kerumitan menunjukkan betapa rumitnya kod itu
• Senarai fungsi dan kelas membantu kami memahami struktur kod
• Import menunjukkan kebergantungan luaran
• Isu menjejaki sebarang masalah yang kami temui

Membina Enjin Analisis Teras

Sekarang untuk teras sebenar — mari bina enjin analisis kod kami:

def analyze_python_code_original(code: str) -> CodeAnalysisResult:
    """Analyze Python code structure and complexity."""
    try:
        tree = ast.parse(code)
        functions = []
        classes = []
        imports = []
        complexity = 0
        for node in ast.walk(tree):
            if isinstance(node, ast.FunctionDef):
                functions.append(node.name)
                complexity += sum(
                    1
                    for _ in ast.walk(node)
                    if isinstance(_, (ast.If, ast.For, ast.While))
                )
            elif isinstance(node, ast.ClassDef):
                classes.append(node.name)
            elif isinstance(node, (ast.Import, ast.ImportFrom)):
                for name in node.names:
                    imports.append(name.name)
        return CodeAnalysisResult(
            complexity=complexity,
            functions=functions,
            classes=classes,
            imports=imports,
            issues=[],
        )
    except Exception as e:
        return CodeAnalysisResult(
            complexity=0, functions=[], classes=[], imports=[], issues=[str(e)]
        )

Fungsi ini seperti detektif kod kami. Ia:

• Menghuraikan kod ke dalam struktur pokok
• Berjalan melalui pokok mencari fungsi, kelas dan import
• Mengira kerumitan dengan mengira struktur kawalan
• Mengembalikan hasil analisis yang komprehensif

Melaksanakan Pemeriksaan Gaya

Kod yang baik bukan sahaja berfungsi dengan betul — ia harus boleh dibaca dan diselenggara. Inilah penyemak gaya kami:

mkdir local_task_planner
cd local_task_planner

Pemeriksa gaya kami memfokuskan pada dua aspek utama:

• Panjang baris — memastikan kod kekal boleh dibaca
• Konvensyen penamaan fungsi — menguatkuasakan gaya sarung ular pilihan Python

Pembantu Dokumentasi

Dokumentasi adalah penting untuk kod yang boleh diselenggara. Inilah penjana dokumentasi kami:

pip install clientai[ollama]

Pembantu ini:

• Mengenal pasti fungsi dan kelas
• Mengekstrak maklumat parameter
• Menghasilkan templat dokumentasi
• Termasuk ruang letak sebagai contoh

Menjadikan Alat Kami Sedia AI

Untuk menyediakan alatan kami untuk penyepaduan dengan sistem AI, kami perlu membungkusnya dalam format mesra JSON:

touch code_analyzer.py

Pembungkus ini menambahkan pengesahan input, penyirian JSON dan pengendalian ralat untuk menjadikan pembantu kami lebih bukti ralat.

Akan Datang dalam Bahagian 2

Dalam siaran ini kami menyediakan persekitaran kami, menstrukturkan hasil kami dan membina fungsi yang akan kami gunakan sebagai alat untuk Ejen kami. Dalam bahagian seterusnya, kami sebenarnya akan mencipta pembantu AI kami, mendaftarkan alatan ini, membina antara muka baris arahan dan melihat pembantu ini bertindak.

Langkah anda seterusnya ialah Bahagian 2: Membina Antara Muka Pembantu dan Barisan Perintah.

Untuk melihat lebih lanjut tentang ClientAI, pergi ke dokumen.

Berhubung dengan Saya

Jika anda mempunyai sebarang soalan, ingin membincangkan topik berkaitan teknologi atau berkongsi maklum balas anda, sila hubungi saya di media sosial:

• GitHub: igorbenav
• X/Twitter: @igorbenav
• LinkedIn: Igor

Atas ialah kandungan terperinci Membina Penyemak Kod AI Tempatan dengan ClientAI dan Ollama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!