neoai.nvim

Neoai

Neoai เป็นปลั๊กอิน NeoVim ที่นำพลังของ GPT-4 ของ OpenAi มาสู่บรรณาธิการของคุณโดยตรง ช่วยให้คุณสร้างรหัสเขียนข้อความใหม่และรับคำแนะนำในบริบทด้วยรหัสของคุณ ปลั๊กอินถูกสร้างขึ้นด้วยอินเทอร์เฟซที่ใช้งานง่ายทำให้ง่ายต่อการโต้ตอบกับ AI และรับความช่วยเหลือที่คุณต้องการ

หมายเหตุ: ปลั๊กอินนี้อยู่ในช่วงต้นมีการเปลี่ยนแปลงเร็วและอาจมีการเปลี่ยนแปลง

แรงจูงใจ

แรงจูงใจหลักที่อยู่เบื้องหลังปลั๊กอินนี้คือการรวมตัวช่วยแชท AI อย่างราบรื่นเช่น CHATGPT เข้าสู่เวิร์กโฟลว์การเข้ารหัส NeoVim ของคุณ เป้าหมายคือการสร้างเครื่องมือที่ทำงานร่วมกับคุณช่วยให้คุณสามารถถามคำถามและรับความช่วยเหลือได้โดยไม่รบกวนการโฟกัสหรือการเข้ารหัสจังหวะ ซึ่งแตกต่างจากปลั๊กอินที่มีอยู่ส่วนใหญ่ซึ่งมีแนวโน้มที่จะจัดลำดับความสำคัญความบันเทิงมากกว่าการผลิตปลั๊กอินนี้เน้นประสิทธิภาพและยูทิลิตี้ ด้วยการอำนวยความสะดวกประสบการณ์การเข้ารหัสที่ราบรื่นและตอบสนองมันมีจุดมุ่งหมายเพื่อเพิ่มประสิทธิภาพการผลิตและทำให้การเข้ารหัสสนุกยิ่งขึ้น

การติดตั้ง

ในการติดตั้ง NeoAI คุณสามารถใช้ Plugin Manager ที่คุณชื่นชอบ ตัวอย่างเช่นด้วย vim-plug ให้เพิ่มบรรทัดต่อไปนี้ใน init.vim หรือ .vimrc ของคุณโปรดทราบว่ามันยังต้องใช้การพึ่งพา NUI และ Curl ที่ติดตั้งในระบบ:

 Plug 'MunifTanjim/nui.nvim'
Plug 'Bryley/neoai.nvim'

จากนั้นเรียกใช้ :PlugInstall เพื่อติดตั้งปลั๊กอิน

สำหรับ lazy.nvim:

 return {
    " Bryley/neoai.nvim " ,
    dependencies = {
        " MunifTanjim/nui.nvim " ,
    },
    cmd = {
        " NeoAI " ,
        " NeoAIOpen " ,
        " NeoAIClose " ,
        " NeoAIToggle " ,
        " NeoAIContext " ,
        " NeoAIContextOpen " ,
        " NeoAIContextClose " ,
        " NeoAIInject " ,
        " NeoAIInjectCode " ,
        " NeoAIInjectContext " ,
        " NeoAIInjectContextCode " ,
    },
    keys = {
        { " <leader>as " , desc = " summarize text " },
        { " <leader>ag " , desc = " generate git message " },
    },
    config = function ()
        require ( " neoai " ). setup ({
            -- Options go here
        })
    end ,
}

สำหรับ Packer:

 use ({
    " Bryley/neoai.nvim " ,
    require = { " MunifTanjim/nui.nvim " },
    cmd = {
        " NeoAI " ,
        " NeoAIOpen " ,
        " NeoAIClose " ,
        " NeoAIToggle " ,
        " NeoAIContext " ,
        " NeoAIContextOpen " ,
        " NeoAIContextClose " ,
        " NeoAIInject " ,
        " NeoAIInjectCode " ,
        " NeoAIInjectContext " ,
        " NeoAIInjectContextCode " ,
    },
    config = function ()
        require ( " neoai " ). setup ({
            -- Options go here
        })
    end ,
})

การแสดงและการใช้งาน

ในการใช้ปลั๊กอินนี้ตรวจสอบให้แน่ใจว่าคุณมีคีย์ OpenAI API ซึ่งสามารถสร้างได้ที่นี่ บันทึกคีย์นี้ในตัวแปรสภาพแวดล้อมของคุณเป็น OPENAI_API_KEY

หมายเหตุสำคัญ : ปลั๊กอินนี้จะไม่รับผิดชอบต่อการซื้อโดยไม่ได้ตั้งใจกับ OpenAI ในขณะที่ใช้ปลั๊กอินนี้ฉันขอแนะนำให้คุณตรวจสอบการใช้งานบัญชีและขีด จำกัด การตั้งค่าบ่อยครั้งดังนั้นคุณจะไม่ใช้จ่ายมากขึ้น

ปลั๊กอินนี้แนะนำ 3 โหมดหรือวิธีการโต้ตอบกับรุ่น AI

โหมด GUI ปกติ

ในโหมดเริ่มต้น GUI จะเปิดขึ้นด้านข้างโดยใช้คำสั่ง :NeoAI ช่วยให้คุณสามารถแชทกับโมเดลได้ การดำเนินการนี้คล้ายกับสิ่งที่คุณได้รับเมื่อใช้ในเบราว์เซอร์ แต่ตอนนี้มันทำให้สะดวกมากขึ้นเมื่อ GUI อยู่ในบรรณาธิการของคุณ

ในบัฟเฟอร์พรอมต์คุณสามารถส่งข้อความได้โดยกด Enter ในขณะที่อยู่ในโหมดแทรก นอกจากนี้คุณสามารถแทรกใหม่ได้โดยใช้การควบคุม Enter การทำแผนที่นี้สามารถเปลี่ยนแปลงได้ในการกำหนดค่า

นอกจากนี้โปรดทราบว่าปลั๊กอินมีคุณสมบัติที่เอาต์พุตจากรุ่นจะถูกบันทึกโดยอัตโนมัติไปยัง g register และตัวอย่างโค้ดทั้งหมดจะถูกบันทึกลงใน c register สิ่งเหล่านี้สามารถเปลี่ยนแปลงได้ในการกำหนดค่า

โหมดบริบท

โหมดบริบททำงานคล้ายกับโหมดปกติ อย่างไรก็ตามคุณมีความสามารถในการให้ข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่คุณต้องการเปลี่ยนแปลง ตัวอย่างเช่นหากคุณกำลังอ่านรหัสของคนอื่นและต้องการคำอธิบายว่ามันทำอะไรคุณสามารถเน้นรหัสในบัฟเฟอร์ผ่านโหมดภาพ จากนั้นคุณสามารถเรียกใช้ :NeoAIContext และพิมพ์บางอย่างเช่น "โปรดอธิบายรหัสนี้ให้ฉัน" ในบัฟเฟอร์พร้อมท์

นอกจากนี้คุณสามารถเน้นข้อความและขอ "แก้ไขเครื่องหมายวรรคตอนและไวยากรณ์ในข้อความนี้" เพื่อให้ได้ข้อความที่ดีกว่า

โปรดทราบว่าหากคุณเรียกใช้คำสั่งโดยไม่มีการเลือกใด ๆ บัฟเฟอร์ทั้งหมดจะถูกส่งผ่าน

โหมดฉีด

โหมดสุดท้ายเรียกว่า "โหมดฉีด" โดยใช้ :NeoAIInject โหมดนี้ทำงานโดยไม่มีส่วนต่อประสานผู้ใช้กราฟิกช่วยให้คุณสามารถส่งพรอมต์ไปยังโมเดลได้อย่างรวดเร็วและให้เอาต์พุตผลลัพธ์ที่แทรกไว้ใต้เคอร์เซอร์ของคุณโดยอัตโนมัติ ทั้งหมดนี้สามารถทำได้โดยไม่ต้องเปิด GUI นอกจากนี้ยังมีโหมดย่อยภายในโหมดฉีดที่สามารถดำเนินการกับบริบท

ทางลัด

คุณสมบัติหนึ่งของปลั๊กอินนี้คือการสร้างทางลัดซึ่งอธิบายไว้ด้านล่าง ปลั๊กอินประกอบด้วยทางลัดสองทางในตัว การปฏิรูปครั้งแรกที่เลือกข้อความเพื่อปรับปรุงความสามารถในการอ่านด้วยการผูกคีย์เริ่มต้นคือ <leader>as (A สำหรับ AI และ S สำหรับการสรุป)

ทางลัดในตัวอื่น ๆ คือการสร้างข้อความ GIT ให้กับคุณโดยอัตโนมัติ:

ข้อควรระวัง : โปรดทราบว่าการใช้คุณลักษณะนี้มากเกินไปอาจนำไปสู่การสะสมข้อมูลที่ส่งไปยังแบบจำลองซึ่งอาจส่งผลให้ต้นทุนสูง เพื่อหลีกเลี่ยงสิ่งนี้ขอแนะนำให้ทำสิ่งเล็ก ๆ น้อย ๆ หรือมีการใช้คุณสมบัติน้อยกว่าบ่อยครั้ง มีความจำเป็นที่จะต้องติดตามการใช้งานของคุณซึ่งสามารถตรวจสอบได้ผ่านลิงค์นี้

การตั้งค่า

ในการตั้งค่าปลั๊กอินให้เพิ่มรหัสต่อไปนี้ด้วยค่าเริ่มต้นใน init.lua ของคุณ (หรือใส่ภายใต้ตัวเลือก config หากใช้ lazy.nvim หรือ packer.nvim

 require ( " neoai " ). setup ({
    -- Below are the default options, feel free to override what you would like changed
    ui = {
        output_popup_text = " NeoAI " ,
        input_popup_text = " Prompt " ,
        width = 30 , -- As percentage eg. 30%
        output_popup_height = 80 , -- As percentage eg. 80%
        submit = " <Enter> " , -- Key binding to submit the prompt
    },
    models = {
        {
            name = " openai " ,
            model = " gpt-3.5-turbo " ,
            params = nil ,
        },
    },
    register_output = {
        [ " g " ] = function ( output )
            return output
        end ,
        [ " c " ] = require ( " neoai.utils " ). extract_code_snippets ,
    },
    inject = {
        cutoff_width = 75 ,
    },
    prompts = {
        context_prompt = function ( context )
            return " Hey, I'd like to provide some context for future "
                .. " messages. Here is the code/text that I want to refer "
                .. " to in our upcoming conversations: nn "
                .. context
        end ,
    },
    mappings = {
        [ " select_up " ] = " <C-k> " ,
        [ " select_down " ] = " <C-j> " ,
    },
    open_ai = {
        api_key = {
            env = " OPENAI_API_KEY " ,
            value = nil ,
            -- `get` is is a function that retrieves an API key, can be used to override the default method.
            -- get = function() ... end

            -- Here is some code for a function that retrieves an API key. You can use it with
            -- the Linux 'pass' application.
            -- get = function()
            --     local key = vim.fn.system("pass show openai/mytestkey")
            --     key = string.gsub(key, "n", "")
            --     return key
            -- end,
        },
    },
    shortcuts = {
        {
            name = " textify " ,
            key = " <leader>as " ,
            desc = " fix text with AI " ,
            use_context = true ,
            prompt = [[
                Please rewrite the text to make it more readable, clear,
                concise, and fix any grammatical, punctuation, or spelling
                errors
            ]] ,
            modes = { " v " },
            strip_function = nil ,
        },
        {
            name = " gitcommit " ,
            key = " <leader>ag " ,
            desc = " generate git commit message " ,
            use_context = false ,
            prompt = function ()
                return [[
                    Using the following git diff generate a consise and
                    clear git commit message, with a short title summary
                    that is 75 characters or less:
                ]] .. vim . fn . system ( " git diff --cached " )
            end ,
            modes = { " n " },
            strip_function = nil ,
        },
    },
})

ตัวเลือก

ฟังก์ชั่นการตั้งค่ายอมรับตารางตัวเลือกเพื่อกำหนดค่าปลั๊กอิน ตัวเลือกที่มีอยู่มีดังนี้:

ตัวเลือก UI

• output_popup_text : ข้อความส่วนหัวที่แสดงในหน้าต่างป๊อปอัพเอาต์พุต (ค่าเริ่มต้น: "neoai")
• input_popup_text : ข้อความส่วนหัวที่แสดงในหน้าต่างอินพุตป๊อปอัพ (ค่าเริ่มต้น: "พรอมต์")
• width : ความกว้างของหน้าต่างเป็นเปอร์เซ็นต์ (เช่น 30 = 30%, ค่าเริ่มต้น: 30)
• output_popup_height : ความสูงของเอาต์พุตป๊อปอัพเป็นเปอร์เซ็นต์ (เช่น 80 = 80%, ค่าเริ่มต้น: 80)
• submit : คีย์มีผลผูกพันในการส่งพรอมต์ หากตั้งค่าจะถูกแมปเพื่อแทรกใหม่ (ค่าเริ่มต้น: "").

ตัวเลือกรุ่น

• models : รายการของรุ่นที่จะใช้:
  • name : ชื่อของผู้ให้บริการรุ่น (เช่น "openai")
  • model : สตริงของชื่อรุ่นที่จะใช้หรือรายการชื่อรุ่น
  • params : ตารางของพารามิเตอร์ที่จะส่งผ่านไปยังโมเดล (เช่นอุณหภูมิ, top_p)

ลงทะเบียนเอาต์พุต

• register_output : ตารางที่มีการลงทะเบียนเป็นคีย์และฟังก์ชั่นที่ใช้เอาต์พุตดิบจาก AI และเอาต์พุตสิ่งที่คุณต้องการบันทึกลงในการลงทะเบียนนั้น ตัวอย่าง:

 register_output = {
    [ " g " ] = function ( output )
        return output
    end ,
    [ " c " ] = require ( " neoai.utils " ). extract_code_snippets ,
}

ตัวเลือกการฉีด

• cutoff_width : เมื่อฉีดถ้าข้อความยาวกว่าค่านี้ควรไปที่บรรทัดใหม่ หากตั้งค่าเป็น NIL ความยาวจะถูกละเว้น (ค่าเริ่มต้น: 75)

ตัวเลือกที่รวดเร็ว

• context_prompt : ฟังก์ชั่นที่สร้างพรอมต์ที่จะใช้เมื่อใช้โหมดบริบท ตัวอย่าง:

 context_prompt = function ( context )
    return " Hi ChatGPT, I'd like to provide some context for future "
        .. " messages. Here is the code/text that I want to refer "
        .. " to in our upcoming conversations: nn "
        .. context
end

ตัวเลือก openai:

• open_api_key_env (เลิกใช้แล้วใช้ api_key.env แทน): ตัวแปรสภาพแวดล้อมที่มีคีย์ OpenAI API ค่าเริ่มต้นคือ "openai_api_key"
• api_key.env : ตัวแปรสภาพแวดล้อมที่มีคีย์ OpenAI API ค่าเริ่มต้นคือ "openai_api_key"
• api_key.value : คีย์ OpenAI API ซึ่งมีความสำคัญเหนือกว่า api_key .env
• api_key.get : ฟังก์ชั่นที่ดึงคีย์ OpenAI API สำหรับการใช้งานตัวอย่างอ้างอิงส่วนการตั้งค่า มันมีความสำคัญสูงกว่า

การทำแผนที่

• mappings : ตารางที่มีการกระทำต่อไปนี้ที่สามารถเป็นคีย์:

  • select_up : เลือกหน้าต่างเอาต์พุตเมื่ออยู่ในหน้าต่างอินพุต
  • select_down : เลือกหน้าต่างอินพุตเมื่ออยู่ในหน้าต่างเอาต์พุต

ค่าคือ keybinding (s) สำหรับการกระทำนั้นหรือ nil ถ้าไม่มีการดำเนินการ

ตัวเลือกทางลัด

• shortcuts : อาร์เรย์ของทางลัด ทางลัดแต่ละอันเป็นตารางที่มี:
• name : สตริง ชื่อทางลัดสามารถเรียกใช้โดยใช้: neoaishortcut
• key : ค่า keybind ที่จะฟังหรือไม่มีถ้าไม่มี keybind สำหรับทางลัด
• desc สตริงหรือไม่มี คำอธิบายของ keybind ถ้ามี
• use_context : หากบริบทจากการเลือก/บัฟเฟอร์ควรใช้
• prompt : พรอมต์ที่จะส่งหรือฟังก์ชั่นเพื่อสร้างพรอมต์เพื่อส่ง
• modes : รายการโหมดที่จะตั้งค่า keybind ขึ้นสำหรับ "n" สำหรับปกติ "v" สำหรับภาพ
• strip_function : ฟังก์ชั่นแถบที่จะใช้ (ไม่บังคับ)

คำสั่งผู้ใช้

: neoai [พรอมต์]

สลับหน้าต่าง Neoai อย่างชาญฉลาด หากหน้าต่างถูกปิดมันจะเปิดและส่ง [พรอมต์] เสริม หากหน้าต่างเปิดและมุ่งเน้นมันจะปิดในที่สุดถ้าหน้าต่างเปิด แต่ไม่ได้โฟกัสมันจะโฟกัสหน้าต่างและส่ง [พรอมต์] เสริม

: neoaitoggle [พรอมต์]

สลับหน้าต่าง Neoai หากหน้าต่างถูกปิดมันจะเปิดและส่ง [พรอมต์] เสริม หากหน้าต่างเปิดอยู่มันจะปิด

: neoaiopen [พรอมต์]

เปิดหน้าต่าง Neoai และส่ง [พรอมต์] เสริม

: neoaiclose

ปิดหน้าต่าง Neoai

: neoaicontext [พรอมต์]

สลับหน้าต่าง Neoai อย่างชาญฉลาดด้วยบริบท หากหน้าต่างถูกปิดมันจะเปิดและส่ง [พรอมต์] เสริม หากหน้าต่างเปิดและมุ่งเน้นมันจะปิดในที่สุดถ้าหน้าต่างเปิด แต่ไม่ได้โฟกัสมันจะโฟกัสหน้าต่างและส่ง [พรอมต์] เสริม บริบทที่ใช้สำหรับคำสั่งนี้คือข้อความที่เลือกด้วยสายตาหรือบัฟเฟอร์ทั้งหมดหากไม่มีการเลือก

: neoaicontextopen [พรอมต์]

เปิดหน้าต่าง Neoai ด้วยบริบทและส่ง [พรอมต์] เสริม บริบทที่ใช้สำหรับคำสั่งนี้คือข้อความที่เลือกด้วยสายตาหรือบัฟเฟอร์ทั้งหมดหากไม่มีการเลือก

: neoaicontextclose

ปิดหน้าต่าง Neoai ด้วยบริบท

: neoaiinject [พรอมต์]

ส่ง [พรอมต์] ไปยัง AI และฉีดการตอบสนอง AI โดยตรงไปยังบัฟเฟอร์โดยไม่ต้องเปิดหน้าต่าง Neoai

: neoaiinjectCode [พรอมต์]

ส่ง [พรอมต์] ไปยัง AI และฉีดการตอบสนอง AI โดยตรงไปยังบัฟเฟอร์โดยไม่ต้องเปิดหน้าต่าง Neoai การตอบสนองจะถูกถอดทุกอย่างยกเว้นตัวอย่างโค้ด

: neoaiinjectContext [พรอมต์]

ส่ง [พรอมต์] ไปยัง AI ด้วยบริบทและฉีดการตอบสนอง AI โดยตรงไปยังบัฟเฟอร์โดยไม่ต้องเปิดหน้าต่าง Neoai บริบทที่ใช้สำหรับคำสั่งนี้คือข้อความที่เลือกด้วยสายตาหรือบัฟเฟอร์ทั้งหมดหากไม่มีการเลือก

: neoaiinjectContextCode [พรอมต์]

ส่ง [พรอมต์] ไปยัง AI ด้วยบริบทและฉีดการตอบสนอง AI โดยตรงไปยังบัฟเฟอร์โดยไม่ต้องเปิดหน้าต่าง Neoai การตอบสนองจะถูกถอดทุกอย่างยกเว้นตัวอย่างโค้ด บริบทที่ใช้สำหรับคำสั่งนี้คือข้อความที่เลือกด้วยสายตาหรือบัฟเฟอร์ทั้งหมดหากไม่มีการเลือก

: neoaishortcut <ลัด>

ทริกเกอร์ทางลัด neoai ที่สร้างขึ้นในการกำหนดค่าผ่านชื่อของมันแทนที่จะเป็น keybinding

แผนงาน:

• ปัญหา 1
  • เพิ่มตัวเลือกคำอธิบายสำหรับทางลัด
  • มีความสามารถในการเรียกใช้ทางลัดผ่านคำสั่งผู้ใช้แทน
• การทดสอบ (เริ่มต้น)
• การแชทหลายครั้ง
• การรวมกล้องโทรทรรศน์
• รุ่นสลับ
• สีที่ดีกว่า (เช่นการไฮไลต์อินพุตของผู้ใช้)
• เน้นบริบทเมื่ออยู่ในบัฟเฟอร์ neoaicontext หรือทำให้บริบทชัดเจน
• Keymap สำหรับการแทนที่บริบทด้วยรหัสที่สร้างขึ้นใหม่
• สนับสนุน:
  • Amazon Codewhisperer
  • GitHub Copilot
• การตรวจจับข้อผิดพลาดที่ดีขึ้น
• การสนทนากลับไปกลับมา
• บริบทโดยใช้โหมดภาพ
• แก้ไขเมื่อใช้: q บน neoai gui
• การกำหนดค่า
• เพิ่ม keybinds ที่กำหนดเองสำหรับปัญหาที่เกี่ยวข้องกับบริบท
• เข้าร่วม Undos of Inject
• บางครั้งการแก้ไขเครื่องหมายการแก้ไขไม่ได้ตั้งค่าโหมดการฉีด
• เอาท์พุทแถบสำหรับรหัสหรืออื่น ๆ
  • ตรวจสอบให้แน่ใจว่าตรงกับจุดสิ้นสุดของไฟล์เช่นกันและใช้สำหรับโหมดการฉีด
• บริบทโดยใช้บัฟเฟอร์
• รหัสแถบจากเอาต์พุตและใส่ในบัฟเฟอร์
• เพิ่มการตั้งค่าการตั้งค่า
• วิธีที่ดีกว่าในการมุ่งเน้นไปที่หน้าต่าง GUI

ใบอนุญาต

ได้รับใบอนุญาตภายใต้ใบอนุญาต MIT ตรวจสอบไฟล์ใบอนุญาตสำหรับรายละเอียด