前摇部分

基本原理

本地增添博客内容(markdown文件)->hexo根据文件内容生成网页源码->上通过指令上传(push)到github->github自行部署静态页面

基本准备

安装git

https://www.cnblogs.com/xueweisuoyong/p/11914045.html

Github shh key

因为把本地写的内容传到github，需要绑定一个ssh密钥
参见：https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent

1

ssh-keygen -t ed25519 -C "guanshengyuanlu@163.com"

把这串公钥添加到github ssh settings里面

安装npm

https://blog.csdn.net/lizhong2008/article/details/133844070
最新版本即可

本地部署

设定本地的git config

1
2

git config --global user.email "guanshengyuanlu@163.com"
git config --global user.name "Draumurvakna"

克隆仓库

1
2

git clone git@github.com:Draumurvakna/MIGAO-Blog-Src.git
cd MIGAO-Blog-Src

安装环境

1
2
3
4

git submodule update --recursive --init   
npm update
cd themes/icarus
npm update

更新网站

1

./show.sh #预览

1

./deploy.sh #可以直接通过网页访https://draumurvakna.github.io/

正文

网站上的每一篇文章在本地都是一份markdown文本文件，存在source/_posts中

通过指令hexo new "article title" 来创建一篇新博客

然后到对应文件里面编辑就行了
markdown的编辑器推荐用typora，当然如果足够硬核的话用txt文本编辑器也毫无问题！

如果想添加图片的话，就往同文件夹下的资源文件夹（和这篇博客名字相同的文件夹）中添加照片然后在文中输入

1

可以参考Sample Blog

添加完自己想要的内容之后用./deploy.sh部署一下网站，稍等片刻，进到网站里就可以看到最新的变化了。

后

我想给博客换个背景

进到themes/icarus/source/img文件夹📁

如果重新部署后发现没有更改，那就网页里按一下<Ctrl>+F5

我想换个头像👤

如上图，改avatar.png

关于评论系统的话需要自己搞定o

参考 https://chen-yulin.github.io/2024/09/03/%5BOBS%5Dhexo-Hexo%20Comment%20System%20--%20Twikoo/

研究生层面的罗斯商学院双学位项目
密大方面提供的硕士学位（授课型）：

• 管理 30 credits
• 供应链（管理）30 credits
• 商务分析 (BA) 36.5 credits 挺适合转商科，量化分析（programming required）

密大的一年放在三年学制的最后一学年的6月~来年5月，我们认对方6学分，对方认我们Gateway
准入条件：

• 密院研究生
• 对方的线上面试方式

学费，5w$~6w$ （如果承认学分学费可以打折），生活安娜堡预计1000$/m，饮食1000$/m， 杂项500$/m

可以提供找工作的签证机会（利好留美发展者）
但是时间会和秋招冲突，会给国内找工作面试带来困难

发学位证书的时间在两边并不统一

26级包括专硕招生（和双学位挂钩）

Useful Link

https://www.youtube.com/watch?v=cLWgjienc_s
https://github.com/habamax/vim-godot

Implementation

Nvim

安装vim-godot, 并且不用手动在配置中开启

1
2

{ "habamax/vim-godot", event = "VimEnter" },

在init.lua中，自动识别godot项目并且开启服务器端口

1
2
3
4
5
6
7

-- for godot
local gdproject = io.open(vim.fn.getcwd() .. "/project.godot", "r")
if gdproject then
	io.close(gdproject)
	vim.fn.serverstart("./godothost")
	vim.notify("Open godot project")
end

在dap/nvim-dap/dap-godot.lua中配置了dap debugger

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

local dap = require("dap")
dap.adapters.godot = {
	type = "server",
	host = "127.0.0.1",
	port = 6006,
}
dap.configurations.gdscript = {
	{
		type = "godot",
		request = "launch",
		name = "Launch scene",
		project = "${workspaceFolder}",
		launch_scene = true,
	},
}

其余dap的默认配置沿用之前的。
lsp:

1
2
3
4

lspconfig.gdscript.setup({
	capabilities = capabilities,
	on_attach = on_attach,
})

Godot Editor

参考视频中在编辑器配置中设置外部编辑器即可。

Reference: http://nilssondev.com/posts/my-journey-with-physics

Things Jolt Does Better

• Upfront about allocations. Jolt expects that you tell it how much memory will be needed for the simulation, which definitely results in better performance since Jolt won’t be reallocating a lot of memory during the simulation. (Jolt does provide a way of doing allocations dynamically, so upfront allocations isn’t a requirement)
• Better multi-core support. Out of the box Jolt will utilize multiple cores very well, whereas I’ve found that PhysX doesn’t utilize multiple cores all too well. Jolt was designed with this in mind whereas PhysX wasn’t.(多线程原生支持)
• Explicitly reference counted objects. When you create a new object in Jolt you’ll most likely get a “Ref” instance back. PhysX does utilize reference counting, but it’s not as apparent as it is with Jolt because PhysX returns pointers to most objects.
• Multiple collision shapes per body. Jolt handles this by providing a “compound” shape, which you construct from multiple other shapes, whereas PhysX just lets you add an arbitrary amount of shapes individually to any body. I’m not entirely sure how PhysX handles this internally, but I do know that Jolt computes these shapes into a single more optimal collision shape, meaning that collision tests are most likely more optimal.（最佳碰撞划分）
• Better Multi-Threaded access. Jolt was designed with this in mind, and most methods in Jolt supports being accessed by multiple threads at once, whereas PhysX requires you to make use of a “Task” system, which is poorly designed in my opinion.（多线程）
• Jolt achieves a higher simulation fidelity / better simulation quality out of the box. Jolt gives us some really good simulation values out of the box, whereas PhysX requires us to play around with a lot of parameters in order to get a high quality simulation.

Things PhysX Does Better

• PhysX has better simulation performance out of the box, whereas Jolt requires more careful setup and usage of the API in order to achieve good performance. Jolt does however gives more opportunities for optimizations, and can achieve better performance overall, but it does require more work（物理准确性方面更好）
• PhysX supports GPU-based simulation by utilizing the CUDA architecture, sadly this is limited to Nvidia GPUs only （可以显卡加速）
• The PhysX Visual Debugger (PVD) supports recording the simulation over the network, Jolt requires us to record the simulation to a file
• The PVD doesn’t just visually record our simulation, but also records the parameters of the simulation at any given moment, allowing us to inspect the parameters more easily. Jolt on the other hand only records the simulation visually.
• PhysX offers us more control over mesh collider cooking, giving us more parameters to mess around with
• PhysX has far better documentation overall, since it’s an older and more widely used API there’s more resources on it online, whereas Jolt lacks online documentation. The developer of Jolt is very active on the GitHub repository though, and has been very helpful with any issues I’ve encountered, or any questions I’ve had about the usage. This isn’t the case with the PhysX developers.（文档更完备）
• Achieves better performance when adding a lot of new bodies during the simulation. Jolt requires us to manually optimize the broadphase structure, and doing that when there’s already a lot of bodies in the broadphase can result in slowdowns temporarily.（在运行时创建物理物体更方便（？））

Objective

I use a hyprland plugin called hyprscroller to emulate the scroll functionality of PaperWM.
However, I can’t get whether I am in row mode or column mode, so I want to show the mode status on my waybar.

Related issue: https://github.com/dawsers/hyprscroller/issues/57

Implementation

I wrote two shell script under ~/.config/waybar/

• scroller_mode_listener.sh, responsible for listening the IPC message of hyprscroller and store that information in a tmp file. This script can be executed in hyprland config file using exec-once

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  #!/bin/bash MODE_FILE="/tmp/hyprland_scroller_mode" function handle { if [[ ${1:0:8} == "scroller" ]]; then if [[ ${1:10:9} == "mode, row" ]]; then echo "Row" > "$MODE_FILE" elif [[ ${1:10:12} == "mode, column" ]]; then echo "Column" > "$MODE_FILE" #else #echo "" > "$MODE_FILE" fi hyprctl dispatch submap reset && pkill -SIGRTMIN+8 waybar # update the widget on waybar fi } # Initialize the mode file echo "" > "$MODE_FILE" socat - "UNIX-CONNECT:$XDG_RUNTIME_DIR/hypr/$HYPRLAND_INSTANCE_SIGNATURE/.socket2.sock" | while read -r line; do handle "$line"; done

• scroller_mode_reader.sh, responsible for reading the tmp file and return the json value to waybar to change the shown icon.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  #!/bin/bash MODE_FILE="/tmp/hyprland_scroller_mode" current_mode=$(cat "$MODE_FILE") if [[ "$current_mode" == "Row" ]]; then icon="Row" percent=0 class="mode-row" elif [[ "$current_mode" == "Column" ]]; then icon="Column" percent=100 class="mode-column" else icon="Row" percent=0 class="" fi echo "{\"text\":\"$icon\", \"tooltip\":\"Scroller Mode: $current_mode\", \"class\":\"$class\",\"percentage\": $percent}"

Then add the custom module to waybar in config file (we use signal to update the module):

1
2
3
4
5
6
7
8
9

"custom/scroller-mode": {
    "exec": "~/.config/waybar/scroller_mode_reader.sh",
    "return-type": "json",
    "interval": "once",
    "signal": 8,
    "on-click": "hyprctl dispatch submap reset && pkill -SIGRTMIN+8 waybar",
    "format": "{icon}",
    "format-icons": ["", ""],
}

Also remember to add the module to the bar:

1

"modules-right": ["custom/scroller-mode", "cpu", "memory", "temperature","battery","clock","custom/power"],

Then everything is done

Basic Plugin File

Just take my ColorfulDiff.nvim as an example.

1
2
3
4
5
6
7
8

$ tree ColorfulDiff.nvim

├── LICENSE
├── lua
│   └── tint.lua
├── plugin
│   └── hello.lua
└── README.md

The lua scripts in plugin/ will be executed automatically and the scripts in lua/ will be called when required

To let nvim load the plugin, use lazy.nvim.
Add this line in your lazy.nvim configuration:

1

{ dir = "/home/cyl/nvim_plugins/ColorfulDiff.nvim/" },

Then this plugin will be loaded on start.

How To Use API

Use :Telescope help_tags or short hand <Ctrl-h> to open the help search panel.
If I want to know the API regarding the highlight:

1
2
3
4
5
6
7
8

 *nvim_buf_add_highlight()*
nvim_buf_add_highlight({buffer}, {ns_id}, {hl_group}, {line},{col_start},{col_end})
    Adds a highlight to buffer.

    Useful for plugins that dynamically generate highlights to a buffer (like
    a semantic highlighter or linter). The function adds a single highlight to a buffer. Unlike |matchaddpos()| highlights follow changes to line
    numbering (as lines are inserted/removed above the highlighted line), like signs and marks do.
    ...

To use this api:

1

vim.api.nvim_buf_add_highlight(...)

Test

Create a new folder called test
And create the test lua file

1
2
3
4
5
6
7
8
9

describe("colorfulDiff", function()
	it("can be required", function()
		require("colorful_diff")
	end)
	it("...", function()
		...
	end)
	...
end)

然后在该文件中按<leader>pt运行测试

1
2

:h lua-plugin
:h write-plugin

Background Introduction to the Methodology: Motion Planning with Transformers

Motion planning is a critical aspect of robotics, enabling robots to navigate complex environments while avoiding obstacles and achieving specific goals. Traditional motion planning methods, such as sampling-based planners, often struggle with high-dimensional tasks and long-term planning due to their reliance on random sampling and tree expansion techniques. Recent advancements in deep learning have led to the development of neural motion planners, which leverage neural networks to learn from demonstrations and generate efficient paths. Among these, the Motion Planning Transformer (MP-Former) framework stands out by treating motion planning as a sequence-to-sequence generation task, utilizing the transformer architecture to capture long-term dependencies and improve path quality.

Experimental Method: Evaluation of MP-Former

In this study, we conducted a series of experiments to evaluate the performance of the MP-Former framework in generating collision-free, near-optimal paths for robotic manipulation tasks. The experiments were designed to compare MP-Former against traditional sampling-based planners and previous neural motion planners in terms of efficiency, path quality, and robustness.

Experimental Details

Sample Information

The experiments utilized a synthetic dataset comprising various complex environments represented as point clouds. Each environment included multiple obstacles and varying configurations to challenge the motion planning capabilities of the algorithms.

Procedures

1. Dataset Preparation: A synthetic dataset was generated, consisting of 100 unique environments with diverse obstacle arrangements. Each environment was represented as a point cloud, simulating real-world scenarios.
2. Algorithm Implementation: The MP-Former framework was implemented alongside traditional planners (e.g., RRT and A*) and previous neural planners (e.g., MPNet). Each algorithm was configured to operate under the same conditions for a fair comparison.
3. Path Generation: For each environment, the algorithms were tasked with generating paths from a predefined start configuration to a goal configuration. The MP-Former generated paths using its transformer-based architecture, while the traditional planners utilized their respective sampling and tree expansion methods.
4. Data Recording: The following metrics were recorded for each generated path:

• Path length (in meters)
• Number of collisions encountered
• Time taken to generate the path (in seconds)
• Success rate (percentage of successful path generations without collisions)

Instruments and Equipment

• Computational Resources: Experiments were conducted on a high-performance computing cluster equipped with NVIDIA GPUs to facilitate the training and evaluation of the MP-Former framework.
• Software Tools: The implementation of the algorithms was carried out using Python with libraries such as TensorFlow for neural network training and Open Motion Planning Library (OMPL) for traditional planners.

Repetitions and Parallel Experiments: Each algorithm was executed 50 times per environment to ensure statistical significance. The results were averaged across these repetitions to provide a comprehensive evaluation of each method’s performance.

Results and Analysis

The results of the experiments were compiled into tables and graphs to illustrate the performance differences between the MP-Former and the other planners.

Table 1: Performance Metrics Comparison

Justification of Methodology

The choice of using the MP-Former framework for motion planning tasks is justified by its ability to efficiently generate high-quality paths while maintaining robustness in complex environments. By treating motion planning as a sequence-to-sequence generation task, MP-Former effectively captures long-term dependencies, reducing the risk of falling into equilibrium points that can hinder traditional planners. The experimental results demonstrate that MP-Former outperforms traditional methods in terms of path quality, efficiency, and success rate, making it a valuable approach for robotic motion planning.

Reference

• Li, B., Wang, R., Chen, Y., Feng, B., Zhou, Q., & Bi, Y. (2025). Motion Planning Transformers (MP-Former): Treat Motion Planning as Sequence-to-Sequence Generation. IEEE International Conference on Robotics and Automation (ICRA).
• Karaman, S., & Frazzoli, E. (2011). Sampling-based algorithms for optimal motion planning. The International Journal of Robotics Research, 30(7), 846-894.
• Gammell, J. D., Srinivasa, S. S., & Barfoot, T. D. (2015). Batch informed trees (BIT*): Sampling-based optimal planning via the heuristically guided search of implicit random geometric graphs. IEEE International Conference on Robotics and Automation (ICRA).

参见 https://dingfen.github.io/2024/07/21/2024-7-21-ai_assist/

阿里云的大模型之前在搞wechat bot的时候接触过，这次再加上一个云函数的服务，就搞定了。
LLM:https://bailian.console.aliyun.com/?spm=a2c4g.11186623.0.0.2db33048PGTSE6#/app-center
云函数:https://fcnext.console.aliyun.com/applications?spm=5176.fcnext.0.0.65f378c8HmZpOP

在本地主要需要做的是在hexo中注入代码
添加文件scripts/injector.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

hexo.extend.injector.register('body_end',`
<link rel="stylesheet" crossorigin href="https://g.alicdn.com/aliyun-documentation/web-chatbot-ui/0.0.11/index.css" />
<script type="module" crossorigin src="https://g.alicdn.com/aliyun-documentation/web-chatbot-ui/0.0.11/index.js"></script>
<script>
  window.CHATBOT_CONFIG = {
    endpoint: "/chat", // 可以替换为 https://{your-fc-http-trigger-domain}/chat
    displayByDefault: false, // 默认不展示 AI 助手聊天框
    aiChatOptions: { // aiChatOptions 中 options 会传递 aiChat 组件，自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat
      conversationOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#conversation-options
        conversationStarters: [
          {prompt: '哪款手机续航最长？'},
          {prompt: '你们有哪些手机型号？'},
          {prompt: '有折叠屏手机吗?'},
        ]
      },
      displayOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#display-options
        height: 600,
      },
      personaOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#chat-personas
        assistant: {
          name: '你好，我是你的 AI 助手',
          // AI 助手的图标
          avatar: 'https://img.alicdn.com/imgextra/i2/O1CN01Pda9nq1YDV0mnZ31H_!!6000000003025-54-tps-120-120.apng',
          tagline: '您可以尝试点击下方的快捷入口开启体验！',
        }
      }
    }
  };
</script>
<style>
  :root {
    /* webchat 工具栏的颜色 */
    --webchat-toolbar-background-color: #1464E4;
    /* webchat 工具栏文字和按钮的颜色 */
    --webchat-toolbar-text-color: #FFF;
  }
  /* webchat 对话框如果被遮挡，可以尝试通过 z-index、bottom、right 等设置来调整位置 */
  .webchat-container {
    z-index: 100;
    bottom: 10px;
    right: 10px;
  }
  /* webchat 的唤起按钮如果被遮挡，可以尝试通过 z-index、bottom、right 等设置来调整位置 */
  .webchat-bubble-tip {
    z-index: 99;
    bottom: 20px;
    right: 20px;
  }
</style>`
);

主要要更改的是window.CHATBOT_CONFIG.endpoint, 改为触发器的公网访问地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

hexo.extend.injector.register('body_end',`
<link rel="stylesheet" crossorigin href="https://g.alicdn.com/aliyun-documentation/web-chatbot-ui/0.0.11/index.css" />
<script type="module" crossorigin src="https://g.alicdn.com/aliyun-documentation/web-chatbot-ui/0.0.11/index.js"></script>
<script>
  window.CHATBOT_CONFIG = {
    endpoint: "https://webchat-bot-iqu-knzhgrvznd.cn-hangzhou.fcapp.run/chat", // 可以替换为 https://{your-fc-http-trigger-domain}/chat
    displayByDefault: false, // 默认不展示 AI 助手聊天框
    aiChatOptions: { // aiChatOptions 中 options 会传递 aiChat 组件，自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat
      conversationOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#conversation-options
        conversationStarters: [
          {prompt: '你是谁？'},
          {prompt: '博主又是谁？'},
          {prompt: '博主喜欢的人是？'},
          {prompt: '想要博主联系方式！'},
        ]
      },
      displayOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#display-options
        height: 600,
      },
      personaOptions: { // 自定义取值参考：https://docs.nlkit.com/nlux/reference/ui/ai-chat#chat-personas
        assistant: {          name: '博主的AI助手，十四行诗参上！',
          // AI 助手的图标
          avatar: 'https://chen-yulin.github.io/thumb/14.png',
          tagline: '要不要试试问下面的问题呢？',
        }
      }
    }
  };
</script>
<style>
  :root {
    /* webchat 工具栏的颜色 */
    --webchat-toolbar-background-color: #1464E4;
    /* webchat 工具栏文字和按钮的颜色 */
    --webchat-toolbar-text-color: #FFF;
  }
  /* webchat 对话框如果被遮挡，可以尝试通过 z-index、bottom、left 等设置来调整位置 */
  .webchat-container {
    z-index: 100;
    bottom: 10px;
    right: 10px;
  }
  /* webchat 的唤起按钮如果被遮挡，可以尝试通过 z-index、bottom、left 等设置来调整位置 */
  .webchat-bubble-tip {
    z-index: 99;
    bottom: 20px;
    right: 20px;
  }
  .webchat-bubble-tip {
    overflow: visible !important;
  }
  @keyframes float {
    0% {
      transform: translateY(0px) translateX(-50%);
    }
    50% {
      transform: translateY(-10px) translateX(-50%);
    }
    100% {
      transform: translateY(0px) translateX(-50%);
    }
  }

  .webchat-bubble-tip::before {
    content: '';
    position: absolute;
    top: -25px;
    left: 70%;
    width: 40px;
    height: 40px;
    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='white'%3E%3Cpath d='M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 14H6l-2 2V4h16v12z'/%3E%3C/svg%3E");
    background-repeat: no-repeat;
    background-position: center;
    background-size: contain;
    filter: drop-shadow(0 4px 6px rgba(0, 0, 0, 0.5));
    animation: float 3s ease-in-out infinite;
  }
</style>
);

最终效果：

仓库地址: https://github.com/yetone/avante.nvim

Accounts

虚拟手机号: https://sms-activate.io/en
（学校邮箱，密码需要大写）

注册Claude-chat
授权Claude-api(https://console.anthropic.com/)

Apply Claude API

Installation

我使用lazy.nvim插件管理器所以非常方便，只需要在lazy_setup.lua里加上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

{
  "yetone/avante.nvim",
  event = "VeryLazy",
  lazy = false,
  version = false, -- set this if you want to always pull the latest change
  opts = {
    -- add any opts here
  },
  -- if you want to build from source then do `make BUILD_FROM_SOURCE=true`
  build = "make",
  -- build = "powershell -ExecutionPolicy Bypass -File Build.ps1 -BuildFromSource false" -- for windows
  dependencies = {
    "nvim-treesitter/nvim-treesitter",
    "stevearc/dressing.nvim",
    "nvim-lua/plenary.nvim",
    "MunifTanjim/nui.nvim",
    --- The below dependencies are optional,
    "nvim-tree/nvim-web-devicons", -- or echasnovski/mini.icons
    "zbirenbaum/copilot.lua", -- for providers='copilot'
    {
      -- support for image pasting
      "HakonHarnes/img-clip.nvim",
      event = "VeryLazy",
      opts = {
        -- recommended settings
        default = {
          embed_image_as_base64 = false,
          prompt_for_file_name = false,
          drag_and_drop = {
            insert_mode = true,
          },
          -- required for Windows users
          use_absolute_path = true,
        },
      },
    },
    {
      -- Make sure to set this up properly if you have lazy=true
      'MeanderingProgrammer/render-markdown.nvim',
      opts = {
        file_types = { "markdown", "Avante" },
      },
      ft = { "markdown", "Avante" },
    },
  },
}

lazy安装完毕之后会有报错：
https://github.com/yetone/avante.nvim/issues/612
解决方案为

1
2

cd ~/.local/share/nvim/lazy/avante.nvim
make BUILD_FROM_SOURCE=true  

配置

添加~/.config/nvim/lua/avante.lua

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314

---NOTE: user will be merged with defaults and
---we add a default var_accessor for this table to config values.

local Utils = require("avante.utils")

---@class avante.CoreConfig: avante.Config
local M = {}

---@class avante.Config
M.defaults = {
	debug = false,
	---@alias Provider "claude" | "openai" | "azure" | "gemini" | "cohere" | "copilot" | [string]
	provider = "claude", -- Only recommend using Claude
	auto_suggestions_provider = "claude",
	---@alias Tokenizer "tiktoken" | "hf"
	-- Used for counting tokens and encoding text.
	-- By default, we will use tiktoken.
	-- For most providers that we support we will determine this automatically.
	-- If you wish to use a given implementation, then you can override it here.
	tokenizer = "tiktoken",
	---@alias AvanteSystemPrompt string
	-- Default system prompt. Users can override this with their own prompt
	-- You can use `require('avante.config').override({system_prompt = "MY_SYSTEM_PROMPT"}) conditionally
	-- in your own autocmds to do it per directory, or that fit your needs.
	system_prompt = [[
Act as an expert software developer.
Always use best practices when coding.
Respect and use existing conventions, libraries, etc that are already present in the code base.
]],
	---@type AvanteSupportedProvider
	openai = {
		endpoint = "https://api.openai.com/v1",
		model = "gpt-4o",
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 4096,
		["local"] = false,
	},
	---@type AvanteSupportedProvider
	copilot = {
		endpoint = "https://api.githubcopilot.com",
		model = "gpt-4o-2024-05-13",
		proxy = nil, -- [protocol://]host[:port] Use this proxy
		allow_insecure = false, -- Allow insecure server connections
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 4096,
	},
	---@type AvanteAzureProvider
	azure = {
		endpoint = "", -- example: "https://<your-resource-name>.openai.azure.com"
		deployment = "", -- Azure deployment name (e.g., "gpt-4o", "my-gpt-4o-deployment")
		api_version = "2024-06-01",
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 4096,
		["local"] = false,
	},
	---@type AvanteSupportedProvider
	claude = {
		endpoint = "https://api.anthropic.com",
		model = "claude-3-5-sonnet-20240620",
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 8000,
		["local"] = false,
	},
	---@type AvanteSupportedProvider
	gemini = {
		endpoint = "https://generativelanguage.googleapis.com/v1beta/models",
		model = "gemini-1.5-flash-latest",
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 4096,
		["local"] = false,
	},
	---@type AvanteSupportedProvider
	cohere = {
		endpoint = "https://api.cohere.com/v1",
		model = "command-r-plus-08-2024",
		timeout = 30000, -- Timeout in milliseconds
		temperature = 0,
		max_tokens = 4096,
		["local"] = false,
	},
	---To add support for custom provider, follow the format below
	---See https://github.com/yetone/avante.nvim/README.md#custom-providers for more details
	---@type {[string]: AvanteProvider}
	vendors = {},
	---Specify the behaviour of avante.nvim
	---1. auto_apply_diff_after_generation: Whether to automatically apply diff after LLM response.
	---                                     This would simulate similar behaviour to cursor. Default to false.
	---2. auto_set_keymaps                : Whether to automatically set the keymap for the current line. Default to true.
	---                                     Note that avante will safely set these keymap. See https://github.com/yetone/avante.nvim/wiki#keymaps-and-api-i-guess for more details.
	---3. auto_set_highlight_group        : Whether to automatically set the highlight group for the current line. Default to true.
	---4. support_paste_from_clipboard    : Whether to support pasting image from clipboard. This will be determined automatically based whether img-clip is available or not.
	behaviour = {
		auto_suggestions = false, -- Experimental stage
		auto_set_highlight_group = true,
		auto_set_keymaps = true,
		auto_apply_diff_after_generation = false,
		support_paste_from_clipboard = false,
	},
	history = {
		storage_path = vim.fn.stdpath("state") .. "/avante",
		paste = {
			extension = "png",
			filename = "pasted-%Y-%m-%d-%H-%M-%S",
		},
	},
	highlights = {
		---@type AvanteConflictHighlights
		diff = {
			current = "DiffText",
			incoming = "DiffAdd",
		},
	},
	mappings = {
		---@class AvanteConflictMappings
		diff = {
			ours = "co",
			theirs = "ct",
			all_theirs = "ca",
			both = "cb",
			cursor = "cc",
			next = "]x",
			prev = "[x",
		},
		suggestion = {
			accept = "<M-l>",
			next = "<M-]>",
			prev = "<M-[>",
			dismiss = "<C-]>",
		},
		jump = {
			next = "]]",
			prev = "[[",
		},
		submit = {
			normal = "<CR>",
			insert = "<C-s>",
		},
		-- NOTE: The following will be safely set by avante.nvim
		ask = "<leader>aa",
		edit = "<leader>ae",
		refresh = "<leader>ar",
		toggle = {
			default = "<leader>at",
			debug = "<leader>ad",
			hint = "<leader>ah",
			suggestion = "<leader>as",
		},
		sidebar = {
			switch_windows = "<Tab>",
			reverse_switch_windows = "<S-Tab>",
		},
	},
	windows = {
		---@alias AvantePosition "right" | "left" | "top" | "bottom"
		position = "right",
		wrap = true, -- similar to vim.o.wrap
		width = 30, -- default % based on available width in vertical layout
		height = 30, -- default % based on available height in horizontal layout
		sidebar_header = {
			align = "center", -- left, center, right for title
			rounded = true,
		},
		input = {
			prefix = "> ",
		},
		edit = {
			border = "rounded",
		},
	},
	--- @class AvanteConflictConfig
	diff = {
		autojump = true,
	},
	--- @class AvanteHintsConfig
	hints = {
		enabled = true,
	},
}

---@type avante.Config
M.options = {}

---@class avante.ConflictConfig: AvanteConflictConfig
---@field mappings AvanteConflictMappings
---@field highlights AvanteConflictHighlights
M.diff = {}

---@type Provider[]
M.providers = {}

---@param opts? avante.Config
function M.setup(opts)
	vim.validate({ opts = { opts, "table", true } })

	M.options = vim.tbl_deep_extend(
		"force",
		M.defaults,
		opts or {},
		---@type avante.Config
		{
			behaviour = {
				support_paste_from_clipboard = M.support_paste_image(),
			},
		}
	)
	M.providers = vim.iter(M.defaults)
		:filter(function(_, value)
			return type(value) == "table" and value.endpoint ~= nil
		end)
		:fold({}, function(acc, k)
			acc = vim.list_extend({}, acc)
			acc = vim.list_extend(acc, { k })
			return acc
		end)

	vim.validate({ provider = { M.options.provider, "string", false } })

	M.diff = vim.tbl_deep_extend(
		"force",
		{},
		M.options.diff,
		{ mappings = M.options.mappings.diff, highlights = M.options.highlights.diff }
	)

	if next(M.options.vendors) ~= nil then
		for k, v in pairs(M.options.vendors) do
			M.options.vendors[k] = type(v) == "function" and v() or v
		end
		vim.validate({ vendors = { M.options.vendors, "table", true } })
		M.providers = vim.list_extend(M.providers, vim.tbl_keys(M.options.vendors))
	end
end

---@param opts? avante.Config
function M.override(opts)
	vim.validate({ opts = { opts, "table", true } })

	M.options = vim.tbl_deep_extend("force", M.options, opts or {})
	M.diff = vim.tbl_deep_extend(
		"force",
		{},
		M.options.diff,
		{ mappings = M.options.mappings.diff, highlights = M.options.highlights.diff }
	)

	if next(M.options.vendors) ~= nil then
		for k, v in pairs(M.options.vendors) do
			M.options.vendors[k] = type(v) == "function" and v() or v
			if not vim.tbl_contains(M.providers, k) then
				M.providers = vim.list_extend(M.providers, { k })
			end
		end
		vim.validate({ vendors = { M.options.vendors, "table", true } })
	end
end

M = setmetatable(M, {
	__index = function(_, k)
		if M.options[k] then
			return M.options[k]
		end
	end,
})

M.support_paste_image = function()
	return Utils.has("img-clip.nvim") or Utils.has("img-clip")
end

M.get_window_width = function()
	return math.ceil(vim.o.columns * (M.windows.width / 100))
end

---@param provider Provider
---@return boolean
M.has_provider = function(provider)
	return M.options[provider] ~= nil or M.vendors[provider] ~= nil
end

---get supported providers
---@param provider Provider
---@return AvanteProviderFunctor
M.get_provider = function(provider)
	if M.options[provider] ~= nil then
		return vim.deepcopy(M.options[provider], true)
	elseif M.vendors[provider] ~= nil then
		return vim.deepcopy(M.vendors[provider], true)
	else
		error("Failed to find provider: " .. provider, 2)
	end
end

M.BASE_PROVIDER_KEYS = {
	"endpoint",
	"model",
	"deployment",
	"api_version",
	"proxy",
	"allow_insecure",
	"api_key_name",
	"timeout",
	-- internal
	"local",
	"_shellenv",
	"tokenizer_id",
	"use_xml_format",
}

return M

~/.config/nvim/init.lua中添加

1

require("plugin-config.avante").setup()

在~/.bashrc添加api key

1

export ANTHROPIC_API_KEY=*** #码了

Fix Error

Error #1

运行时出现这个报错

由于这个PR没有被merge所以决定fork一下这个仓库再应用更改

然后将该plugin的仓库地址改为我自己的

Error #2

使用WildCard服务 https://bewildcard.com/card ，具体账密见密码簿

Error #3

发现服务器无响应

• 设置终端proxy export https_proxy=127.0.0.1:7897
  尝试输入

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  curl https://api.anthropic.com/v1/messages \ 130 -H "x-api-key: <api-key>" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-3-sonnet-20240229", "max_tokens": 1024, "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'

• sudo conda update curl to solve curl(77) error
• export CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt

参考: https://forum-zh.obsidian.md/t/topic/292

文献搜集网站

Google Scholar 114
Connected Papers

总结了各文章之间的 关联度，太直观了

文献管理软件

Zotero