1132 lines
39 KiB
Markdown
1132 lines
39 KiB
Markdown
# Cell Toolbar Actions v2 — 实现计划
|
|
|
|
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans. Steps use checkbox (`- [ ]`) syntax.
|
|
|
|
**Goal:** 在 v1 基础上把 3 按钮合并为单图标按钮 + inline 输入框;彻底删除 `mode` 概念(前端不发、服务端不读不返);修 settings 实时生效;成功时替换 cell 源码。
|
|
|
|
**Architecture:** 前端 `OpenCodeCellActions` 渲染单 🪄 图标;点击 → `OpenCodeInlinePrompt` widget 附加到 `cell.node` 显示输入框;提交 POST `/opencode-bridge/edit` body `{prompt, context, providerId?, modelId?}`(无 `mode`)。后端 `EditHandler` 用唯一统一系统提示词构造 OpenCode parts,`SessionManager` 保证 1 notebook 1 sid。`index.ts` 订阅 `settings.changed` 实时刷新 runtime。
|
|
|
|
**Tech Stack:** TypeScript / JupyterLab 4.5.10 / Python 3.12 (tornado) / jest / pytest-jupyter / stylelint / prettier
|
|
|
|
**Spec:** `docs/superpowers/specs/2026-07-23-cell-toolbar-actions-v2-design.md`(已批准)
|
|
|
|
## Global Constraints
|
|
|
|
- 前端 request body **绝不**包含 `mode` 字段。
|
|
- 服务端 `EditHandler` **绝不**读 `body["mode"]`、**绝不**在响应里回 `mode` 字段。
|
|
- `OpenCodeMode` 类型别名删除;`OpenCodeRequest.mode` 和 `OpenCodeSuccess.mode` 字段删除。
|
|
- `MODE_SYSTEM_PROMPTS` 字典删除;统一为单一 `UNIFIED_SYSTEM_PROMPT` 常量(包含子串 `"你是一个代码编辑助手"` 以兼容 `test_edit_handler` 既有断言)。
|
|
- toolbar item 名 `opencode-cell-actions` 不变;rank 保持 100。
|
|
- 工具按钮不显示在 markdown cell(non-CodeCell 返回空 `Widget`)。
|
|
- inline 输入框在 cell 内的位置:`Widget.attach(inlineWidget, cell.node)` 追加到 cell DOM 末尾,CSS 给边框使其作为 cell 内的内嵌面板呈现。
|
|
- 无新 npm / pip 依赖;REST 契约变化(去 mode)向后兼容(多余 `mode` 字段被忽略)。
|
|
- 代码风格:prettier(single quotes、无 trailing commas、无 arrow parens);CSS 类名 kebab-case;Python PEP 8。
|
|
|
|
---
|
|
|
|
### Task 1: 后端删 mode + 统一系统提示词(TDD)
|
|
|
|
**Files:**
|
|
- Modify: `opencode_bridge/routes.py`
|
|
- Modify: `opencode_bridge/tests/test_routes.py`(只改 `test_edit_handler`)
|
|
|
|
**Interfaces:**
|
|
- Consumes: 无新外部依赖;`OpenCodeClient.send_message_sync(sid, parts, provider_id, model_id, system)` 不变;`SessionManager.get_or_create / invalidate` 不变。
|
|
- Produces:`_build_request_body(prompt: str, context: dict) -> dict`(无 mode 参数);`UNIFIED_SYSTEM_PROMPT: str` 常量;`EditHandler.post` 接受 body `{prompt, context, providerId?, modelId?}`(无 mode)。
|
|
|
|
- [ ] **Step 1: 改写 `opencode_bridge/routes.py`**
|
|
|
|
完整新内容(注意:删 `MODE_SYSTEM_PROMPTS`、`_build_request_body` 去 mode 参数、`<instruction>` 守卫删除、`EditHandler` 不读不回 mode):
|
|
|
|
```python
|
|
import json
|
|
|
|
import logging
|
|
|
|
from jupyter_server.base.handlers import APIHandler
|
|
from jupyter_server.utils import url_path_join
|
|
import tornado
|
|
|
|
from .config import resolve_config
|
|
from .opencode_client import OpenCodeClient, OpenCodeError
|
|
from .session_manager import SessionManager
|
|
|
|
|
|
log = logging.getLogger("opencode_bridge.routes")
|
|
|
|
|
|
# Unified system prompt — the LLM (OpenCode) itself judges whether the user's
|
|
# natural-language instruction is an optimize / fix / edit request, based on
|
|
# the code context and the optional <traceback> in the parts below.
|
|
UNIFIED_SYSTEM_PROMPT = (
|
|
"你是一个代码编辑助手。基于提供的代码上下文（以及 traceback，如果有），"
|
|
"按照用户的指令修改代码。返回只包含修改后完整代码的回复，"
|
|
"不要任何解释或 markdown 围栏。"
|
|
)
|
|
|
|
|
|
def make_client(handler: APIHandler) -> OpenCodeClient:
|
|
"""Factory for OpenCodeClient. Tests monkey-patch this."""
|
|
cfg = resolve_config(handler.settings.get("opencode_bridge", {}))
|
|
return OpenCodeClient(cfg)
|
|
|
|
|
|
def get_session_manager(handler: APIHandler) -> SessionManager:
|
|
"""Return the SessionManager singleton for this web app, creating on first use.
|
|
|
|
Stored in handler.settings["opencode_bridge_session_manager"] so it survives
|
|
across requests but is per-server-instance. Tests monkey-patch this.
|
|
"""
|
|
sm = handler.settings.get("opencode_bridge_session_manager")
|
|
if sm is None:
|
|
def client_factory() -> OpenCodeClient:
|
|
cfg = resolve_config(handler.settings.get("opencode_bridge", {}))
|
|
return OpenCodeClient(cfg)
|
|
sm = SessionManager(client_factory)
|
|
handler.settings["opencode_bridge_session_manager"] = sm
|
|
return sm
|
|
|
|
|
|
def _build_request_body(prompt: str, context: dict) -> dict:
|
|
"""Build full request body for OpenCode POST /session/:id/message.
|
|
|
|
Returns dict with 'parts' (list) and 'system' (str) keys. No mode concept:
|
|
the LLM interprets the user's natural-language instruction, with the code
|
|
context and the optional traceback in front of it.
|
|
"""
|
|
parts: list[dict] = []
|
|
|
|
if context.get("previousCode"):
|
|
parts.append({
|
|
"type": "text",
|
|
"text": "<previous_cell>\n%s\n</previous_cell>\n" % context["previousCode"],
|
|
})
|
|
|
|
error = context.get("error")
|
|
if error:
|
|
parts.append({
|
|
"type": "text",
|
|
"text": (
|
|
"<traceback>\n%s: %s\n" % (error["ename"], error["evalue"])
|
|
+ "\n".join(error.get("traceback", []))
|
|
+ "\n</traceback>\n"
|
|
),
|
|
})
|
|
|
|
parts.append({
|
|
"type": "text",
|
|
"text": "<cell language='%s'>\n%s\n</cell>\n" % (
|
|
context.get("language", "python"),
|
|
context["source"],
|
|
),
|
|
})
|
|
|
|
if prompt:
|
|
parts.append({"type": "text", "text": "<instruction>\n%s\n</instruction>" % prompt})
|
|
|
|
return {"parts": parts, "system": UNIFIED_SYSTEM_PROMPT}
|
|
|
|
|
|
def _strip_code_fence(s: str) -> str:
|
|
"""Strip ```language ... ``` fences from LLM output."""
|
|
s = s.strip()
|
|
if s.startswith("```"):
|
|
lines = s.split("\n")
|
|
if lines[0].startswith("```"):
|
|
lines = lines[1:]
|
|
if lines and lines[-1].startswith("```"):
|
|
lines = lines[:-1]
|
|
return "\n".join(lines).strip()
|
|
return s
|
|
|
|
|
|
class HelloRouteHandler(APIHandler):
|
|
# The following decorator should be present on all verb methods (head, get, post,
|
|
# patch, put, delete, options) to ensure only authorized user can request the
|
|
# Jupyter server
|
|
@tornado.web.authenticated
|
|
def get(self):
|
|
self.finish(json.dumps({
|
|
"data": (
|
|
"Hello, world!"
|
|
" This is the '/opencode-bridge/hello' endpoint."
|
|
" Try visiting me in your browser!"
|
|
),
|
|
}))
|
|
|
|
|
|
class HealthHandler(APIHandler):
|
|
@tornado.web.authenticated
|
|
async def get(self):
|
|
try:
|
|
client = make_client(self)
|
|
data = await client.health()
|
|
self.finish(json.dumps({
|
|
"ok": data.get("healthy", False),
|
|
"version": data.get("version"),
|
|
"endpoint": client.endpoint,
|
|
}))
|
|
except Exception as e:
|
|
log.exception("health check failed")
|
|
self.set_status(503)
|
|
self.finish(json.dumps({
|
|
"ok": False,
|
|
"error": str(e),
|
|
"endpoint": make_client(self).endpoint,
|
|
}))
|
|
|
|
|
|
class ProvidersHandler(APIHandler):
|
|
@tornado.web.authenticated
|
|
async def get(self):
|
|
try:
|
|
data = await make_client(self).list_providers()
|
|
self.finish(json.dumps(data))
|
|
except Exception as e:
|
|
log.exception("providers list failed")
|
|
self.set_status(502)
|
|
self.finish(json.dumps({"error": str(e)}))
|
|
|
|
|
|
class EditHandler(APIHandler):
|
|
@tornado.web.authenticated
|
|
async def post(self):
|
|
try:
|
|
body = json.loads(self.request.body)
|
|
prompt = body.get("prompt", "")
|
|
context = body["context"]
|
|
provider_id = body.get("providerId") or None
|
|
model_id = body.get("modelId") or None
|
|
notebook_path = context.get("notebookPath", "")
|
|
except (KeyError, json.JSONDecodeError) as e:
|
|
self.set_status(400)
|
|
self.finish(json.dumps({"error": "bad request: %s" % e}))
|
|
return
|
|
|
|
if not notebook_path:
|
|
self.set_status(400)
|
|
self.finish(json.dumps({"error": "missing context.notebookPath"}))
|
|
return
|
|
|
|
client = make_client(self)
|
|
sm = get_session_manager(self)
|
|
try:
|
|
sid = await sm.get_or_create(notebook_path)
|
|
request_body = _build_request_body(prompt, context)
|
|
result = await client.send_message_sync(
|
|
sid,
|
|
request_body["parts"],
|
|
provider_id=provider_id,
|
|
model_id=model_id,
|
|
system=request_body["system"],
|
|
)
|
|
|
|
text_parts = [
|
|
p.get("text", "")
|
|
for p in result.get("parts", [])
|
|
if p.get("type") == "text"
|
|
]
|
|
final_source = _strip_code_fence("\n".join(text_parts).strip())
|
|
|
|
self.finish(json.dumps({
|
|
"ok": True,
|
|
"finalSource": final_source,
|
|
"sessionId": sid,
|
|
"notebookPath": notebook_path,
|
|
}))
|
|
except OpenCodeError as e:
|
|
# If session is invalid on OpenCode side, invalidate cache.
|
|
# 404 / 410 / "session not found" -> next get_or_create will recreate.
|
|
if "404" in str(e) or "not found" in str(e).lower():
|
|
sm.invalidate(notebook_path)
|
|
log.warning("invalidated dead session for %s", notebook_path)
|
|
log.exception("edit failed")
|
|
self.set_status(502)
|
|
self.finish(json.dumps({"ok": False, "error": str(e)}))
|
|
except Exception as e:
|
|
log.exception("edit failed")
|
|
self.set_status(502)
|
|
self.finish(json.dumps({"ok": False, "error": str(e)}))
|
|
# NO finally delete — session is reused per notebook.
|
|
|
|
|
|
class SessionListHandler(APIHandler):
|
|
"""List all active notebook -> session mappings. Debug endpoint."""
|
|
|
|
@tornado.web.authenticated
|
|
def get(self):
|
|
sm = get_session_manager(self)
|
|
self.finish(json.dumps({"sessions": sm.list_sessions()}))
|
|
|
|
|
|
class SessionReleaseHandler(APIHandler):
|
|
"""Release the OpenCode session for a specific notebook.
|
|
|
|
Query param: notebook=<notebook path, URL-encoded>
|
|
"""
|
|
|
|
@tornado.web.authenticated
|
|
async def delete(self):
|
|
notebook_path = self.get_query_argument("notebook", "")
|
|
if not notebook_path:
|
|
self.set_status(400)
|
|
self.finish(json.dumps({"error": "missing 'notebook' query parameter"}))
|
|
return
|
|
sm = get_session_manager(self)
|
|
deleted = await sm.release(notebook_path)
|
|
self.finish(json.dumps({
|
|
"ok": True,
|
|
"notebookPath": notebook_path,
|
|
"deleted": deleted,
|
|
}))
|
|
|
|
|
|
def setup_route_handlers(web_app):
|
|
host_pattern = ".*$"
|
|
base_url = web_app.settings["base_url"]
|
|
|
|
handlers = [
|
|
(url_path_join(base_url, "opencode-bridge", "hello"), HelloRouteHandler),
|
|
(url_path_join(base_url, "opencode-bridge", "health"), HealthHandler),
|
|
(url_path_join(base_url, "opencode-bridge", "providers"), ProvidersHandler),
|
|
(url_path_join(base_url, "opencode-bridge", "edit"), EditHandler),
|
|
(url_path_join(base_url, "opencode-bridge", "sessions"), SessionListHandler),
|
|
(url_path_join(base_url, "opencode-bridge", "session"), SessionReleaseHandler),
|
|
]
|
|
|
|
web_app.add_handlers(host_pattern, handlers)
|
|
```
|
|
|
|
- [ ] **Step 2: 改 `test_edit_handler` 去掉请求体里的 `mode`**
|
|
|
|
在 `opencode_bridge/tests/test_routes.py` 中,`test_edit_handler` 函数(约 line 108)把请求体构造:
|
|
|
|
```python
|
|
body = json.dumps({
|
|
"mode": "edit",
|
|
"prompt": "Add type hints",
|
|
"context": {
|
|
"notebookPath": "test.ipynb",
|
|
"cellId": "cell-1",
|
|
"language": "python",
|
|
"cellIndex": 0,
|
|
"totalCells": 1,
|
|
"source": "def foo(): return 42\n",
|
|
"previousCode": None,
|
|
"error": None,
|
|
},
|
|
})
|
|
```
|
|
|
|
改为(删除 `"mode": "edit",` 一行):
|
|
|
|
```python
|
|
body = json.dumps({
|
|
"prompt": "Add type hints",
|
|
"context": {
|
|
"notebookPath": "test.ipynb",
|
|
"cellId": "cell-1",
|
|
"language": "python",
|
|
"cellIndex": 0,
|
|
"totalCells": 1,
|
|
"source": "def foo(): return 42\n",
|
|
"previousCode": None,
|
|
"error": None,
|
|
},
|
|
})
|
|
```
|
|
|
|
其余断言(系统提示词含 "你是一个代码编辑助手"、`sessionId`、`notebookPath`、`send_message_sync` 走 SessionManager 而非直接 create/delete)保持不变 —— 新版服务端下它们仍应通过。
|
|
|
|
- [ ] **Step 3: 跑测试确认通过**
|
|
|
|
Run: `.venv/bin/python -m pytest opencode_bridge/tests/test_routes.py -v`
|
|
Expected: `test_hello`, `test_health_handler`, `test_providers_handler`, `test_edit_handler`, `test_session_list_handler`, `test_session_release_handler` 全部通过(共 6 个)。
|
|
|
|
- [ ] **Step 4: Commit**
|
|
|
|
```bash
|
|
git add opencode_bridge/routes.py opencode_bridge/tests/test_routes.py
|
|
git commit -m "refactor: drop mode from backend; unify system prompt
|
|
|
|
Removes the optimize/fix/edit mode-routing on the server and collapses to
|
|
a single unified system prompt. The LLM itself judges the user's intent
|
|
from natural language + code context (+ optional traceback). The frontend
|
|
no longer sends mode; the response no longer echoes it."
|
|
```
|
|
|
|
---
|
|
|
|
### Task 2: 前端 types 去 mode + settings 实时生效
|
|
|
|
**Files:**
|
|
- Modify: `src/types.ts`
|
|
- Modify: `src/index.ts`
|
|
- (可能)Modify: `src/__tests__/opencode_client.spec.ts`(若它构造的 `OpenCodeRequest` 包含 `mode`)
|
|
|
|
**Interfaces:**
|
|
- Consumes: 无新依赖;`ISettingRegistry` 已用;`setOpenCodeRuntime` 签名不变。
|
|
- Produces: `OpenCodeMode` 类型别名**删除**;`OpenCodeRequest = { prompt, context, providerId?, modelId? }`(无 mode);`OpenCodeSuccess = { ok, finalSource, sessionId, notebookPath }`(无 mode);`index.ts` 订阅 `settings.changed` → 重新 `setOpenCodeRuntime`。
|
|
|
|
- [ ] **Step 1: 改 `src/types.ts`**
|
|
|
|
把:
|
|
```ts
|
|
export type OpenCodeMode = 'optimize' | 'fix' | 'edit';
|
|
|
|
export interface OpenCodeRequest {
|
|
mode: OpenCodeMode;
|
|
prompt: string;
|
|
context: CellContext;
|
|
providerId?: string;
|
|
modelId?: string;
|
|
}
|
|
|
|
export interface OpenCodeSuccess {
|
|
ok: true;
|
|
mode: OpenCodeMode;
|
|
finalSource: string;
|
|
sessionId: string;
|
|
notebookPath: string;
|
|
}
|
|
```
|
|
|
|
改为:
|
|
```ts
|
|
export interface OpenCodeRequest {
|
|
prompt: string;
|
|
context: CellContext;
|
|
providerId?: string;
|
|
modelId?: string;
|
|
}
|
|
|
|
export interface OpenCodeSuccess {
|
|
ok: true;
|
|
finalSource: string;
|
|
sessionId: string;
|
|
notebookPath: string;
|
|
}
|
|
```
|
|
(`OpenCodeMode` 类型别名整行删除。)
|
|
|
|
- [ ] **Step 2: 改 `src/index.ts` 订阅 `settings.changed`**
|
|
|
|
当前(在 `settingRegistry.load(...).then(settings => { ... setOpenCodeRuntime(...) ... })` 内):
|
|
```ts
|
|
void settingRegistry
|
|
.load(plugin.id)
|
|
.then(settings => {
|
|
const bridge = readOpenCodeSettings(settings.composite);
|
|
setOpenCodeRuntime({
|
|
settings: bridge,
|
|
serverSettings: app.serviceManager.serverSettings
|
|
});
|
|
console.log('opencode_bridge settings loaded:', bridge);
|
|
...
|
|
```
|
|
|
|
把 `then(settings => { ... })` 回调改为:
|
|
```ts
|
|
void settingRegistry
|
|
.load(plugin.id)
|
|
.then(settings => {
|
|
const apply = () => {
|
|
const bridge = readOpenCodeSettings(settings.composite);
|
|
setOpenCodeRuntime({
|
|
settings: bridge,
|
|
serverSettings: app.serviceManager.serverSettings
|
|
});
|
|
console.log('opencode_bridge settings applied:', bridge);
|
|
};
|
|
apply();
|
|
settings.changed.connect(apply);
|
|
...
|
|
```
|
|
(把 `setOpenCodeRuntime` + log 包成 `apply`,先调一次,再 `settings.changed.connect(apply)` 订阅后续变更。`callOpenCodeProviders` 那段保持不变。)
|
|
|
|
- [ ] **Step 3: 同步 `opencode_client.spec.ts`(若需要)**
|
|
|
|
Read `src/__tests__/opencode_client.spec.ts`。若测试里构造的 `OpenCodeRequest` 包含 `mode` 字段,删除之;若 mock 的 `OpenCodeSuccess` 含 `mode`,删除之;若断言响应里含 `mode`,删除之。具体按文件实际内容改。
|
|
|
|
- [ ] **Step 4: 跑测试确认通过**
|
|
|
|
Run: `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm test`
|
|
Expected: 全过(若 opencode_client.spec.ts 报错"mode required"则回到 Step 3 修)。
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
git add src/types.ts src/index.ts src/__tests__/opencode_client.spec.ts
|
|
git commit -m "refactor: drop mode from frontend types; react to settings changes
|
|
|
|
OpenCodeMode removed; OpenCodeRequest and OpenCodeSuccess no longer carry a
|
|
mode field. index.ts now subscribes to settings.changed so JupyterLab
|
|
Settings Editor changes (provider, model, server URL, etc.) take effect on
|
|
the next request without a reload."
|
|
```
|
|
|
|
---
|
|
|
|
### Task 3: 前端组件改造为单按钮 + inline 输入框(TDD)
|
|
|
|
**Files:**
|
|
- Modify: `src/components/opencode_cell_actions.ts`
|
|
- Create: `src/components/opencode_inline_prompt.ts`(新文件,inline 输入框 widget)
|
|
- Modify: `src/__tests__/opencode_cell_actions.spec.ts`
|
|
|
|
**Interfaces:**
|
|
- Consumes: Task 2 后的 `OpenCodeRequest`(无 mode)、`OpenCodeResponse`、`OpenCodeSettings`、`callOpenCodeEdit`、`extractCellContext`;`Widget` / `Notification` / `CodeCell` 类型。
|
|
- Produces: `class OpenCodeCellActions extends Widget` —— 渲染单个 🪄 图标按钮 + (按钮下方) inline 标签文本 "AI 智能编辑";点击 → 通过 `OpenCodeInlinePrompt` 切换 cell 内的输入面板;提交 `POST { prompt, context, providerId?, modelId? }`(无 mode);成功 → `cell.model.sharedModel.setSource(resp.finalSource)` + Notification;失败 → Notification。
|
|
- 同步:导出 `setOpenCodeRuntime` 仍在 `opencode_cell_actions.ts`(保持调用方 import 路径不变)。
|
|
|
|
- [ ] **Step 1: 写新单测(覆盖新行为)** — 完整替换 `src/__tests__/opencode_cell_actions.spec.ts`:
|
|
|
|
```typescript
|
|
/**
|
|
* Unit tests for OpenCodeCellActions (single AI button) and OpenCodeInlinePrompt
|
|
* (inline input panel inside the cell).
|
|
*
|
|
* Mocks @jupyterlab/cells, @jupyterlab/apputils, and @lumino/widgets at the
|
|
* test boundary so the real ESM packages are not loaded.
|
|
*/
|
|
jest.mock('@jupyterlab/cells', () => ({
|
|
CodeCell: class CodeCell {}
|
|
}));
|
|
|
|
jest.mock('@jupyterlab/apputils', () => ({
|
|
Notification: {
|
|
info: jest.fn(),
|
|
error: jest.fn(),
|
|
success: jest.fn(),
|
|
warning: jest.fn()
|
|
}
|
|
}));
|
|
|
|
jest.mock('@lumino/widgets', () => {
|
|
class Widget {
|
|
public node: HTMLElement = document.createElement('div');
|
|
public id = '';
|
|
public parent: Widget | null = null;
|
|
private _isDisposed = false;
|
|
public get isDisposed(): boolean {
|
|
return this._isDisposed;
|
|
}
|
|
public addClass(cls: string): void {
|
|
this.node.classList.add(cls);
|
|
}
|
|
public dispose(): void {
|
|
this._isDisposed = true;
|
|
}
|
|
public static attach(widget: Widget, host: HTMLElement): void {
|
|
host.appendChild(widget.node);
|
|
}
|
|
}
|
|
return { Widget };
|
|
});
|
|
|
|
import { OpenCodeCellActions } from '../components/opencode_cell_actions';
|
|
import { OpenCodeInlinePrompt } from '../components/opencode_inline_prompt';
|
|
import { CodeCell } from '@jupyterlab/cells';
|
|
import { Widget } from '@lumino/widgets';
|
|
|
|
function makeFakeOutputs(items: any[]): any {
|
|
return {
|
|
get length() {
|
|
return items.length;
|
|
},
|
|
get(i: number) {
|
|
return items[i];
|
|
}
|
|
};
|
|
}
|
|
|
|
function makeFakeCell(
|
|
source: string,
|
|
errorOutputs: any[] = [],
|
|
notebookPath = 'foo.ipynb',
|
|
cellIndex = 0,
|
|
totalCells = 1
|
|
): CodeCell {
|
|
const model: any = {
|
|
id: 'cell-test',
|
|
type: 'code',
|
|
sharedModel: {
|
|
getSource: () => source,
|
|
setSource: jest.fn()
|
|
},
|
|
outputs: makeFakeOutputs(errorOutputs),
|
|
contentChanged: { connect: jest.fn(), disconnect: jest.fn() },
|
|
stateChanged: { connect: jest.fn(), disconnect: jest.fn() }
|
|
};
|
|
const cell = new (CodeCell as unknown as new () => CodeCell)();
|
|
(cell as any).model = model;
|
|
|
|
const notebook: any = { widgets: [] as CodeCell[] };
|
|
const panel: any = {
|
|
context: { path: notebookPath },
|
|
content: notebook
|
|
};
|
|
for (let i = 0; i < cellIndex; i++) {
|
|
notebook.widgets.push({
|
|
model: { sharedModel: { getSource: () => '' } }
|
|
} as any);
|
|
}
|
|
notebook.widgets.push(cell);
|
|
for (let i = cellIndex + 1; i < totalCells; i++) {
|
|
notebook.widgets.push({
|
|
model: { sharedModel: { getSource: () => '' } }
|
|
} as any);
|
|
}
|
|
|
|
Object.defineProperty(cell, 'parent', {
|
|
value: notebook,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(notebook, 'parent', {
|
|
value: panel,
|
|
configurable: true
|
|
});
|
|
|
|
return cell as CodeCell;
|
|
}
|
|
|
|
describe('OpenCodeCellActions', () => {
|
|
it('renders a single AI button (not 3 buttons)', () => {
|
|
const cell = makeFakeCell('x = 1');
|
|
const actions = new OpenCodeCellActions(cell);
|
|
const btns = actions.node.querySelectorAll('button');
|
|
expect(btns.length).toBe(1);
|
|
expect(btns[0].textContent).toContain('🪄');
|
|
});
|
|
|
|
it('disables the button when notebook panel cannot be resolved', () => {
|
|
const cell = new (CodeCell as unknown as new () => CodeCell)();
|
|
(cell as any).model = {
|
|
id: 'orphan',
|
|
type: 'code',
|
|
sharedModel: { getSource: () => 'x = 1', setSource: jest.fn() },
|
|
outputs: makeFakeOutputs([]),
|
|
contentChanged: { connect: jest.fn(), disconnect: jest.fn() },
|
|
stateChanged: { connect: jest.fn(), disconnect: jest.fn() }
|
|
};
|
|
const actions = new OpenCodeCellActions(cell);
|
|
const btn = actions.node.querySelector('button') as HTMLButtonElement;
|
|
expect(btn.disabled).toBe(true);
|
|
});
|
|
|
|
it('clicking the button attaches an OpenCodeInlinePrompt to the cell', () => {
|
|
const cell = makeFakeCell('x = 1');
|
|
const actions = new OpenCodeCellActions(cell);
|
|
// Attach actions to cell so it can resolve parent chain
|
|
Object.defineProperty(actions, 'parent', { value: cell, configurable: true });
|
|
(actions as any).onAfterAttach({} as any);
|
|
|
|
const btn = actions.node.querySelector('button') as HTMLButtonElement;
|
|
btn.click();
|
|
|
|
const prompt = cell.node.querySelector(
|
|
'.opencode-inline-prompt'
|
|
) as HTMLElement;
|
|
expect(prompt).not.toBeNull();
|
|
});
|
|
|
|
it('clicking the button twice detaches the inline prompt', () => {
|
|
const cell = makeFakeCell('x = 1');
|
|
const actions = new OpenCodeCellActions(cell);
|
|
Object.defineProperty(actions, 'parent', { value: cell, configurable: true });
|
|
(actions as any).onAfterAttach({} as any);
|
|
|
|
const btn = actions.node.querySelector('button') as HTMLButtonElement;
|
|
btn.click();
|
|
btn.click();
|
|
const prompt = cell.node.querySelector('.opencode-inline-prompt');
|
|
expect(prompt).toBeNull();
|
|
});
|
|
|
|
it('disconnects model signals on dispose', () => {
|
|
const cell = makeFakeCell('x = 1');
|
|
const actions = new OpenCodeCellActions(cell);
|
|
actions.dispose();
|
|
const model = (cell as any).model;
|
|
expect(model.contentChanged.disconnect).toHaveBeenCalled();
|
|
expect(model.stateChanged.disconnect).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('OpenCodeInlinePrompt', () => {
|
|
it('renders a textarea, a send and a cancel button', () => {
|
|
const cell = makeFakeCell('x = 1');
|
|
const prompt = new OpenCodeInlinePrompt(cell, {
|
|
onSubmit: jest.fn(),
|
|
onCancel: jest.fn(),
|
|
disabled: false
|
|
});
|
|
expect(prompt.node.querySelector('textarea')).not.toBeNull();
|
|
expect(prompt.node.querySelectorAll('button').length).toBe(2);
|
|
});
|
|
});
|
|
```
|
|
|
|
(注:本轮我们把 inline 输入框拆成独立 `OpenCodeInlinePrompt` widget。`cell.node.appendChild(actions.node)` 不在测试范围 —— 测试通过断言 `cell.node.querySelector('.opencode-inline-prompt')` 验证。Mock `Widget.attach` 追加到 `host.appendChild(widget.node)`。)
|
|
|
|
- [ ] **Step 2: 跑测试确认失败**
|
|
|
|
Run: `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm test opencode_cell_actions`
|
|
Expected: FAIL —— `OpenCodeInlinePrompt` 模块找不到(因为还没建),以及现有 component 行为不匹配新断言(1 button 而非 3)。
|
|
|
|
- [ ] **Step 3: 新建 `src/components/opencode_inline_prompt.ts`** — inline 输入框 widget
|
|
|
|
```typescript
|
|
/**
|
|
* Inline prompt widget attached to a cell's DOM when the AI button is clicked.
|
|
* Renders a textarea + send/cancel buttons. The owning cell is passed so
|
|
* we can resolve the cell context at submit time. submit/cancel are
|
|
* callbacks owned by OpenCodeCellActions.
|
|
*/
|
|
import { CodeCell } from '@jupyterlab/cells';
|
|
import { Widget } from '@lumino/widgets';
|
|
|
|
export interface IOpenCodeInlinePromptOptions {
|
|
onSubmit: (text: string) => void;
|
|
onCancel: () => void;
|
|
disabled: boolean;
|
|
}
|
|
|
|
export class OpenCodeInlinePrompt extends Widget {
|
|
private _textarea: HTMLTextAreaElement;
|
|
private _sendBtn: HTMLButtonElement;
|
|
private _cancelBtn: HTMLButtonElement;
|
|
|
|
constructor(
|
|
private _cell: CodeCell,
|
|
options: IOpenCodeInlinePromptOptions
|
|
) {
|
|
super();
|
|
this.addClass('opencode-inline-prompt');
|
|
this._textarea = document.createElement('textarea');
|
|
this._textarea.placeholder = '向 AI 描述你想要的修改…';
|
|
this._textarea.rows = 3;
|
|
this._sendBtn = document.createElement('button');
|
|
this._sendBtn.className = 'opencode-btn-send';
|
|
this._sendBtn.textContent = '🚀 发送';
|
|
this._sendBtn.disabled = options.disabled;
|
|
this._sendBtn.addEventListener('click', () => {
|
|
const text = this._textarea.value;
|
|
if (text.trim()) {
|
|
options.onSubmit(text);
|
|
}
|
|
});
|
|
this._cancelBtn = document.createElement('button');
|
|
this._cancelBtn.className = 'opencode-btn-cancel';
|
|
this._cancelBtn.textContent = '✕ 取消';
|
|
this._cancelBtn.addEventListener('click', () => {
|
|
options.onCancel();
|
|
});
|
|
|
|
const actions = document.createElement('div');
|
|
actions.className = 'opencode-inline-actions';
|
|
actions.appendChild(this._sendBtn);
|
|
actions.appendChild(this._cancelBtn);
|
|
|
|
this.node.appendChild(this._textarea);
|
|
this.node.appendChild(actions);
|
|
}
|
|
|
|
setDisabled(disabled: boolean): void {
|
|
this._sendBtn.disabled = disabled;
|
|
}
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 4: 重写 `src/components/opencode_cell_actions.ts`**
|
|
|
|
完整新内容:
|
|
|
|
```typescript
|
|
/**
|
|
* Per-cell AI action button rendered inside JupyterLab's native Cell toolbar
|
|
* (top-right of the active cell). v2: a single icon button. Clicking it
|
|
* toggles an OpenCodeInlinePrompt panel attached to the cell's DOM.
|
|
*
|
|
* Registered in index.ts via IToolbarWidgetRegistry.addFactory('Cell', ...).
|
|
*
|
|
* The frontend does NO semantic processing: it gathers the cell's source /
|
|
* outputs / error, attaches the user's freeform instruction, and POSTs to
|
|
* the server. The server (and the LLM it forwards to) decides what to do.
|
|
*/
|
|
import type { CodeCell } from '@jupyterlab/cells';
|
|
import { Notification } from '@jupyterlab/apputils';
|
|
import type { NotebookPanel } from '@jupyterlab/notebook';
|
|
import { ServerConnection } from '@jupyterlab/services';
|
|
import { Widget } from '@lumino/widgets';
|
|
|
|
import { callOpenCodeEdit } from '../api/opencode_client';
|
|
import { extractCellContext } from '../context/cell_context';
|
|
import type {
|
|
CellContext,
|
|
OpenCodeRequest,
|
|
OpenCodeResponse,
|
|
OpenCodeSettings
|
|
} from '../types';
|
|
|
|
import { OpenCodeInlinePrompt } from './opencode_inline_prompt';
|
|
|
|
// Module-level runtime injection (set by index.ts after settings load).
|
|
let _settings: OpenCodeSettings | null = null;
|
|
let _serverSettings: ServerConnection.ISettings | null = null;
|
|
|
|
export function setOpenCodeRuntime(args: {
|
|
settings: OpenCodeSettings;
|
|
serverSettings: ServerConnection.ISettings;
|
|
}): void {
|
|
_settings = args.settings;
|
|
_serverSettings = args.serverSettings;
|
|
}
|
|
|
|
type Status = 'idle' | 'loading';
|
|
|
|
export class OpenCodeCellActions extends Widget {
|
|
private _cell: CodeCell;
|
|
private _context: CellContext | null = null;
|
|
private _status: Status = 'idle';
|
|
private _prompt: OpenCodeInlinePrompt | null = null;
|
|
|
|
constructor(cell: CodeCell) {
|
|
super();
|
|
this._cell = cell;
|
|
this.addClass('opencode-cell-actions');
|
|
this._cell.model.contentChanged.connect(this._onModelChange, this);
|
|
this._cell.model.stateChanged.connect(this._onModelChange, this);
|
|
this._render();
|
|
this._onModelChange();
|
|
}
|
|
|
|
dispose(): void {
|
|
if (this.isDisposed) {
|
|
return;
|
|
}
|
|
this._cell.model.contentChanged.disconnect(this._onModelChange, this);
|
|
this._cell.model.stateChanged.disconnect(this._onModelChange, this);
|
|
this._hidePrompt();
|
|
super.dispose();
|
|
}
|
|
|
|
private _onModelChange(): void {
|
|
this._context = extractCellContextFromCell(this._cell);
|
|
if (this._prompt) {
|
|
this._prompt.setDisabled(!this._context || this._status === 'loading');
|
|
}
|
|
}
|
|
|
|
private _render(): void {
|
|
const node = this.node;
|
|
node.textContent = '';
|
|
|
|
const baseDisabled = !this._context || this._status === 'loading';
|
|
|
|
const btn = document.createElement('button');
|
|
btn.className = 'opencode-btn opencode-btn-ai';
|
|
btn.textContent = '🪄 AI 智能编辑';
|
|
btn.disabled = baseDisabled;
|
|
btn.title = baseDisabled
|
|
? 'OpenCode: 等待 cell 上下文…'
|
|
: '让 AI 修改这个 cell 的代码';
|
|
btn.addEventListener('click', () => {
|
|
this._togglePrompt();
|
|
});
|
|
node.appendChild(btn);
|
|
}
|
|
|
|
private _togglePrompt(): void {
|
|
if (this._prompt) {
|
|
this._hidePrompt();
|
|
} else {
|
|
this._showPrompt();
|
|
}
|
|
}
|
|
|
|
private _showPrompt(): void {
|
|
if (this._prompt) {
|
|
return;
|
|
}
|
|
const prompt = new OpenCodeInlinePrompt(this._cell, {
|
|
disabled: !this._context || this._status === 'loading',
|
|
onSubmit: (text: string) => {
|
|
void this._onSubmit(text);
|
|
},
|
|
onCancel: () => {
|
|
this._hidePrompt();
|
|
}
|
|
});
|
|
Widget.attach(prompt, this._cell.node);
|
|
this._prompt = prompt;
|
|
}
|
|
|
|
private _hidePrompt(): void {
|
|
if (this._prompt) {
|
|
this._prompt.dispose();
|
|
this._prompt = null;
|
|
}
|
|
}
|
|
|
|
private async _onSubmit(text: string): Promise<void> {
|
|
if (!this._context) {
|
|
return;
|
|
}
|
|
if (!_settings || !_serverSettings) {
|
|
Notification.error('OpenCode 运行时未初始化,请检查 settings');
|
|
return;
|
|
}
|
|
|
|
const request: OpenCodeRequest = {
|
|
prompt: text,
|
|
context: this._context,
|
|
providerId: _settings.opencodeProvider || undefined,
|
|
modelId: _settings.opencodeModel || undefined
|
|
};
|
|
|
|
this._status = 'loading';
|
|
if (this._prompt) {
|
|
this._prompt.setDisabled(true);
|
|
}
|
|
|
|
try {
|
|
const resp = await callOpenCodeEdit(request, _serverSettings);
|
|
this._handleResponse(resp);
|
|
} catch (e) {
|
|
this._status = 'idle';
|
|
if (this._prompt) {
|
|
this._prompt.setDisabled(false);
|
|
}
|
|
Notification.error(`OpenCode 失败: ${(e as Error).message}`);
|
|
}
|
|
}
|
|
|
|
private _handleResponse(resp: OpenCodeResponse): void {
|
|
this._status = 'idle';
|
|
if (resp.ok) {
|
|
this._cell.model.sharedModel.setSource(resp.finalSource);
|
|
Notification.info(
|
|
`OpenCode 完成 (${resp.finalSource.length} chars). Session: ${resp.sessionId.slice(0, 8)}…`
|
|
);
|
|
this._hidePrompt();
|
|
} else {
|
|
if (this._prompt) {
|
|
this._prompt.setDisabled(false);
|
|
}
|
|
Notification.error(`OpenCode 错误: ${resp.error}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolve a CodeCell's parent NotebookPanel by walking the parent chain,
|
|
* then build the CellContext.
|
|
*/
|
|
function extractCellContextFromCell(cell: CodeCell): CellContext | null {
|
|
let node: Widget | null = cell.parent;
|
|
let notebookPanel: NotebookPanel | null = null;
|
|
while (node) {
|
|
const candidate = node as any;
|
|
if (
|
|
candidate.context &&
|
|
candidate.content &&
|
|
Array.isArray(candidate.content.widgets)
|
|
) {
|
|
notebookPanel = candidate;
|
|
break;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
if (!notebookPanel) {
|
|
return null;
|
|
}
|
|
return extractCellContext(cell, notebookPanel);
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 5: 跑测试确认通过**
|
|
|
|
Run: `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm test opencode_cell_actions`
|
|
Expected: 6 tests pass(5 actions + 1 inline prompt widget 的基础渲染测试)。
|
|
|
|
- [ ] **Step 6: 跑全套测试**
|
|
|
|
Run: `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm test`
|
|
Expected: 全过。
|
|
|
|
- [ ] **Step 7: Commit**
|
|
|
|
```bash
|
|
git add src/components/opencode_cell_actions.ts src/components/opencode_inline_prompt.ts src/__tests__/opencode_cell_actions.spec.ts
|
|
git commit -m "feat: single AI action button with inline prompt; replace cell source
|
|
|
|
v2: collapse 3 buttons (optimize/fix/edit) into one icon button. Clicking
|
|
it opens an OpenCodeInlinePrompt widget attached to the cell's DOM with a
|
|
textarea + send/cancel. On submit the request body is {prompt, context,
|
|
providerId?, modelId?} — no mode field, the backend (and the LLM) decides
|
|
what to do. On success the cell source is replaced via
|
|
sharedModel.setSource(resp.finalSource)."
|
|
```
|
|
|
|
---
|
|
|
|
### Task 4: CSS 改造 + client 单测同步
|
|
|
|
**Files:**
|
|
- Modify: `style/base.css`(单按钮 + inline 面板样式)
|
|
- (可能)Modify: `src/__tests__/opencode_client.spec.ts`(若它含 mode 断言,Task 2 漏掉的)
|
|
|
|
**Interfaces:**
|
|
- 无。
|
|
|
|
- [ ] **Step 1: 重写 `style/base.css`**
|
|
|
|
完整新内容(替换整个文件):
|
|
|
|
```css
|
|
/*
|
|
See the JupyterLab Developer Guide for useful CSS Patterns:
|
|
|
|
https://jupyterlab.readthedocs.io/en/stable/developer/css.html
|
|
*/
|
|
|
|
/* Single AI action button inside the native Cell toolbar (active cell, top-right). */
|
|
.opencode-cell-actions {
|
|
display: flex;
|
|
align-items: center;
|
|
}
|
|
|
|
.opencode-cell-actions .opencode-btn {
|
|
border: none;
|
|
background: transparent;
|
|
padding: 0 6px;
|
|
font-size: var(--jp-ui-font-size1);
|
|
line-height: 20px;
|
|
cursor: pointer;
|
|
white-space: nowrap;
|
|
}
|
|
|
|
.opencode-cell-actions .opencode-btn:hover:enabled {
|
|
background: var(--jp-layout-color2);
|
|
border-radius: 2px;
|
|
}
|
|
|
|
.opencode-cell-actions .opencode-btn:disabled {
|
|
opacity: 0.4;
|
|
cursor: default;
|
|
}
|
|
|
|
/* Inline prompt panel attached to the cell when the AI button is clicked. */
|
|
.opencode-inline-prompt {
|
|
display: flex;
|
|
flex-direction: column;
|
|
gap: 4px;
|
|
padding: 6px;
|
|
margin: 4px 8px;
|
|
border: 1px solid var(--jp-border-color2, #ddd);
|
|
border-radius: 4px;
|
|
background: var(--jp-layout-color1, #fff);
|
|
}
|
|
|
|
.opencode-inline-prompt textarea {
|
|
width: 100%;
|
|
resize: vertical;
|
|
font-family: var(--jp-code-font-family, monospace);
|
|
font-size: var(--jp-code-font-size, 13px);
|
|
box-sizing: border-box;
|
|
}
|
|
|
|
.opencode-inline-prompt .opencode-inline-actions {
|
|
display: flex;
|
|
justify-content: flex-end;
|
|
gap: 4px;
|
|
}
|
|
|
|
.opencode-inline-prompt .opencode-inline-actions button {
|
|
border: 1px solid var(--jp-border-color2, #ccc);
|
|
background: var(--jp-layout-color2, #f7f7f7);
|
|
padding: 2px 8px;
|
|
border-radius: 3px;
|
|
cursor: pointer;
|
|
font-size: var(--jp-ui-font-size1);
|
|
}
|
|
|
|
.opencode-inline-prompt .opencode-inline-actions button:hover:enabled {
|
|
background: var(--jp-layout-color3, #eaeaea);
|
|
}
|
|
|
|
.opencode-inline-prompt .opencode-inline-actions button:disabled {
|
|
opacity: 0.4;
|
|
cursor: default;
|
|
}
|
|
```
|
|
|
|
- [ ] **Step 2: 最终全量验证**
|
|
|
|
Run: `.venv/bin/python -m pytest opencode_bridge/tests/ -v` && `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm test` && `YARN_NODE_LINKER=node-modules PATH="$PWD/.venv/bin:$PATH" .venv/bin/jlpm build`
|
|
Expected: 三个全过。
|
|
|
|
- [ ] **Step 3: Commit**
|
|
|
|
```bash
|
|
git add style/base.css
|
|
git commit -m "style: single AI button + inline prompt panel CSS"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 5: design.md 同步(CC)
|
|
|
|
**Files:**
|
|
- Modify: `design.md` §2(交互)+ §3(API contract)
|
|
|
|
- [ ] **Step 1: 改写 §2** — 完整替换该节第 1 条(单按钮)+ 新增 inline 输入框描述
|
|
|
|
把 §2 第 1 条:
|
|
> 1. **悬浮 Toolbar(常驻)**:在每个 `CodeCell` 顶部渲染微型操作栏:
|
|
> * `✨ 优化`:自动提炼代码规范与性能。
|
|
> * `🐛 智能排错`:(**仅当 Cell 有 Error Output 时亮起**)自动抓取 Traceback 并修复。
|
|
> * `🪄 智能编辑`:展开内嵌 Prompt 输入框。
|
|
|
|
替换为:
|
|
```
|
|
1. **原生 Cell Toolbar 单按钮(2026-07-23 v2 修正)**:不再自绘悬浮 toolbar,也合并了 v1 的三个 mode(优化/排错/编辑)为单个 `🪄 AI 智能编辑` 图标按钮。通过 `IToolbarWidgetRegistry.addFactory('Cell', 'opencode-cell-actions', ...)` 注入 JupyterLab 原生 cell toolbar,显示在 **active cell 右上角**(move up/down 按钮旁,`rank: 100` 排在 delete 右侧);仅 `CodeCell` 显示,随 active cell 切换移动。前端不做任何语义处理 —— 不再发 `mode` 字段,后端用统一的系统提示词 + 用户的自然语言指令 + 上下文(含 traceback)由 LLM 自己判断是优化/排错/编辑。
|
|
```
|
|
|
|
把 §2 第 2 条:
|
|
> 2. **Inline Prompt 框(按需展开)**:
|
|
> * 用户点击 `🪄 智能编辑` 后,在当前 Cell 下方平滑展开一个微型输入框(带 `Textarea` + `🚀 发送` 按钮)。
|
|
|
|
替换为:
|
|
```
|
|
2. **Inline Prompt 输入框(v2 实现)**:点击 `🪄 AI 智能编辑` 按钮后,`OpenCodeInlinePrompt` widget 追加到当前 `CodeCell` 的 DOM 末尾,呈现内嵌输入面板:多行 `textarea`(placeholder "向 AI 描述你想要的修改…",无默认值)+ `🚀 发送` + `✕ 取消` 两个按钮。提交时前端仅收集 cell `source` / `outputs` / `error` 与用户在 textarea 里写的指令,POST `/opencode-bridge/edit`,body 为 `{prompt, context, providerId?, modelId?}`(无 `mode`)。**成功** → 前端调用 `cell.model.sharedModel.setSource(resp.finalSource)` 就地替换 cell 源码 + Notification.info;**失败** → Notification.error,输入框保留(可改文案重发)。Session 由服务端 `SessionManager` 保证 1 notebook 1 sid(前端不感知)。
|
|
```
|
|
|
|
- [ ] **Step 2: 改写 §3 接口契约**(去掉 `action` mode 分类)
|
|
|
|
把 §3 整节"接口契约设计 (API Contract)"下的 Request Payload 示例:
|
|
```
|
|
"action": "custom_edit", // custom_edit | fix_error | optimize
|
|
```
|
|
那行连同它上面的字段说明,改为没有 `mode` / `action` 的描述;强调 body 是 `{prompt, context, providerId?, modelId?}`;响应是 `{ok, finalSource, sessionId, notebookPath}`。
|
|
|
|
- [ ] **Step 3: Commit**
|
|
|
|
```bash
|
|
git add design.md
|
|
git commit -m "docs: design.md v2 interaction + contract (single button, no mode)"
|
|
```
|
|
|
|
---
|
|
|
|
### Task 6: 手动验收(用户执行,非自动化)
|
|
|
|
启动 `jupyter lab`,打开任一 `.ipynb`:
|
|
- active cell 右上角出现单个 `🪄 AI 智能编辑` 按钮(delete 按钮右侧,toolbar 不换行)
|
|
- 切换 active cell 按钮随之移动
|
|
- 点击按钮 → cell 底部出现输入框(带边框,textarea + 发送/取消)
|
|
- 输入指令 → 发送 → cell 源码被替换为 AI 返回的代码;右上角 Notification.info
|
|
- Jupyter Settings Editor 修改 `opencodeProvider` / `opencodeModel` / `opencodeServerUrl` → 下一条请求即生效(无需 reload)
|
|
- 非 CodeCell(markdown)不显示按钮
|