nexforge-cli 0.1.1__tar.gz → 0.2.0__tar.gz

{nexforge_cli-0.1.1 → nexforge_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexforge-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: NexForgeCLI — 一个面向 DeepSeek V4 的终端智能体(TUI + CLI 双模式)
 Project-URL: Homepage, https://gitee.com/Lighthorn/nexforgecli
 Author: NexForge
@@ -22,6 +22,7 @@ Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27
 Requires-Dist: openai>=1.40
 Requires-Dist: pydantic>=2.6
+Requires-Dist: pyperclip>=1.8
 Requires-Dist: rich>=13.7
 Requires-Dist: textual>=0.60
 Provides-Extra: dev

nexforge_cli-0.2.0/doc/layout-F2.md

@@ -0,0 +1,42 @@
+# F2 多行输入弹窗布局
+
+## CSS
+```css
+MultilineInputModal {
+    align: center middle;
+}
+MultilineInputModal > Vertical {
+    width: 80;
+    height: 30;
+    background: #1a1a24;
+    border: round #6D5EF5;
+    padding: 1 2;
+}
+#mli-title {
+    color: #6D5EF5;
+    text-style: bold;
+    height: auto;
+}
+#mli-textarea {
+    height: 1fr;
+    margin: 1 0;
+}
+```
+
+## 结构
+```
+┌──────────────────────────────────────┐
+│ 标题 (height: auto)                  │
+│                                      │
+│ TextArea (height: 1fr)               │
+│                                      │
+│ [发送]                    [取消]     │
+│ (独立 Button,非 Horizontal)         │
+└──────────────────────────────────────┘
+```
+
+## 关键规则
+- 外层 Vertical: `height: 30`, `align: center middle`
+- TextArea: `height: 1fr` 占满剩余空间
+- 按钮: **两个独立 Button**(不用 Horizontal 容器),垂直排列贴底
+- 总高: 30 行,内容区自动扩展

{nexforge_cli-0.1.1 → nexforge_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nexforge-cli"
-version = "0.1.1"
+version = "0.2.0"
 description = "NexForgeCLI — 一个面向 DeepSeek V4 的终端智能体(TUI + CLI 双模式)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -32,6 +32,7 @@ dependencies = [
     "openai>=1.40",
     "pydantic>=2.6",
     "httpx>=0.27",
+    "pyperclip>=1.8",
 ]
 
 [project.optional-dependencies]

{nexforge_cli-0.1.1 → nexforge_cli-0.2.0}/src/nexforge/core/session.py

@@ -1,55 +1,55 @@
-"""会话状态:消息列表 + 累计用量。
-
-关键规则(DeepSeek):发生工具调用的回合,assistant 的 reasoning_content
-必须回传给 API,否则 400;无工具调用的最终回合无需回传。
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from nexforge.core.types import AssistantMessage, Usage
-
-DEFAULT_SYSTEM = (
-    "你是 NexForgeCLI,一个运行在终端里的智能体助手,由 DeepSeek V4 驱动。\n"
-    "你可以调用工具读写文件、执行命令来完成用户的编码任务。\n"
-    "回答用简洁的中文;修改文件用 edit_file 工具;需要执行命令用 run_shell。\n"
-    "完成任务后用一两句话总结你做了什么。\n"
-    "不要用 emoji(📦🌤等),用纯文本或 Markdown 列表/表格表示信息。\n"
-    "执行 Shell 命令前先用 run_shell 探测操作系统(Windows用cmd命令,Linux/macOS用bash命令)。"
-)
-
-
-@dataclass
-class Session:
-    system_prompt: str = DEFAULT_SYSTEM
-    messages: list[dict] = field(default_factory=list)
-    total_usage: Usage = field(default_factory=Usage)
-
-    def __post_init__(self) -> None:
-        if not self.messages:
-            self.messages.append({"role": "system", "content": self.system_prompt})
-
-    def add_user(self, text: str) -> None:
-        self.messages.append({"role": "user", "content": text})
-
-    def add_assistant(self, msg: AssistantMessage) -> None:
-        # 始终回传 reasoning_content(DeepSeek 多轮思考对话要求)
-        include_reasoning = bool(msg.reasoning_content)
-        self.messages.append(msg.to_message_dict(include_reasoning=include_reasoning))
-        if msg.usage:
-            self.total_usage = self.total_usage + msg.usage
-
-    def add_tool_result(self, tool_call_id: str, content: str) -> None:
-        self.messages.append(
-            {"role": "tool", "tool_call_id": tool_call_id, "content": content}
-        )
-
-    def inject_skill_index(self, idx: str) -> None:
-        """在 system 消息后插入技能索引。"""
-        if idx and self.messages:
-            self.messages.insert(1, {"role": "system", "content": idx})
-
-    def approx_context_tokens(self) -> int:
-        chars = sum(len(str(m.get("content") or "")) for m in self.messages)
-        return chars // 4
+"""会话状态:消息列表 + 累计用量。
+
+关键规则(DeepSeek):发生工具调用的回合,assistant 的 reasoning_content
+必须回传给 API,否则 400;无工具调用的最终回合无需回传。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from nexforge.core.types import AssistantMessage, Usage
+
+DEFAULT_SYSTEM = (
+    "你是 NexForgeCLI,一个运行在终端里的智能体助手,由 DeepSeek V4 驱动。\n"
+    "你可以调用工具读写文件、执行命令来完成用户的编码任务。\n"
+    "回答用简洁的中文;修改文件用 edit_file 工具;需要执行命令用 run_shell。\n"
+    "完成任务后用一两句话总结你做了什么。\n"
+    "不要用 emoji(📦🌤等),用纯文本或 Markdown 列表/表格表示信息。\n"
+    "执行 Shell 命令前先用 run_shell 探测操作系统(Windows用cmd命令,Linux/macOS用bash命令)。"
+)
+
+
+@dataclass
+class Session:
+    system_prompt: str = DEFAULT_SYSTEM
+    messages: list[dict] = field(default_factory=list)
+    total_usage: Usage = field(default_factory=Usage)
+
+    def __post_init__(self) -> None:
+        if not self.messages:
+            self.messages.append({"role": "system", "content": self.system_prompt})
+
+    def add_user(self, text: str) -> None:
+        self.messages.append({"role": "user", "content": text})
+
+    def add_assistant(self, msg: AssistantMessage) -> None:
+        # 始终回传 reasoning_content(DeepSeek 多轮思考对话要求)
+        include_reasoning = bool(msg.reasoning_content)
+        self.messages.append(msg.to_message_dict(include_reasoning=include_reasoning))
+        if msg.usage:
+            self.total_usage = self.total_usage + msg.usage
+
+    def add_tool_result(self, tool_call_id: str, content: str) -> None:
+        self.messages.append(
+            {"role": "tool", "tool_call_id": tool_call_id, "content": content}
+        )
+
+    def inject_skill_index(self, idx: str) -> None:
+        """在 system 消息后插入技能索引。"""
+        if idx and self.messages:
+            self.messages.insert(1, {"role": "system", "content": idx})
+
+    def approx_context_tokens(self) -> int:
+        chars = sum(len(str(m.get("content") or "")) for m in self.messages)
+        return chars // 4

{nexforge_cli-0.1.1 → nexforge_cli-0.2.0}/src/nexforge/provider/deepseek.py

@@ -1,204 +1,204 @@
-"""DeepSeek V4 Provider —— 基于 OpenAI 兼容 SDK。
-
-要点(核实自 api-docs.deepseek.com):
-- 模型:deepseek-v4-flash / deepseek-v4-pro
-- 思考模式:extra_body={"thinking":{"type":"enabled"|"disabled"}} + reasoning_effort
-- 思考链走 reasoning_content(流式为 delta.reasoning_content)
-- 思考模式忽略 temperature/top_p/penalty,故思考开启时不传这些参数
-- 工具调用的回合必须回传 reasoning_content(由 Session/Agent 负责)
-- 缓存字段:usage.prompt_cache_hit_tokens / prompt_cache_miss_tokens
-"""
-
-from __future__ import annotations
-
-from typing import Any, AsyncIterator
-
-from openai import AsyncOpenAI
-
-from nexforge.config import Effort, NexForgeConfig, Tier
-from nexforge.core.types import (
-    AssistantMessage,
-    ChunkKind,
-    StreamChunk,
-    ToolCall,
-    Usage,
-)
-
-
-class ProviderError(RuntimeError):
-    """Provider 层的可读错误(缺 key、网络、API 报错)。"""
-
-
-def _extra(obj: Any, name: str) -> Any:
-    """从 openai 返回对象里取标准字段或 extra 字段(DeepSeek 自定义字段)。"""
-    val = getattr(obj, name, None)
-    if val is not None:
-        return val
-    extra = getattr(obj, "model_extra", None)
-    if isinstance(extra, dict):
-        return extra.get(name)
-    return None
-
-
-class DeepSeekProvider:
-    def __init__(self, config: NexForgeConfig):
-        self.config = config
-        key = config.resolve_api_key()
-        if not key:
-            raise ProviderError(
-                f"未找到 API Key。请设置环境变量 {config.provider.api_key_env},"
-                f"或在 {config.provider.base_url} 对应的 config.toml 中填写 api_key。"
-            )
-        self._client = AsyncOpenAI(
-            api_key=key,
-            base_url=config.provider.base_url,
-            timeout=config.provider.timeout,
-            max_retries=config.provider.max_retries,
-        )
-
-    async def aclose(self) -> None:
-        await self._client.close()
-
-    def _build_kwargs(
-        self,
-        messages: list[dict],
-        tools: list[dict] | None,
-        tier: Tier | None,
-        thinking: bool | None,
-        effort: Effort | None,
-    ) -> dict:
-        cfg = self.config
-        think = cfg.models.thinking if thinking is None else thinking
-        eff = effort or cfg.models.reasoning_effort
-        # DeepSeek 专有参数走 extra_body(直接进请求体顶层)
-        extra_body: dict[str, Any] = {
-            "thinking": {"type": "enabled" if think else "disabled"}
-        }
-        if think:
-            extra_body["reasoning_effort"] = eff
-
-        kwargs: dict[str, Any] = {
-            "model": cfg.model_id(tier),
-            "messages": messages,
-            "stream": True,
-            "stream_options": {"include_usage": True},
-            "extra_body": extra_body,
-        }
-        # max_tokens vs max_completion_tokens(DeepSeek 推荐新参数)
-        if cfg.models.use_max_completion_tokens:
-            kwargs["max_completion_tokens"] = cfg.models.max_output_tokens
-        else:
-            kwargs["max_tokens"] = cfg.models.max_output_tokens
-        # 采样参数(仅 thinking=off 生效)
-        if not think:
-            m = cfg.models
-            if m.temperature is not None:
-                kwargs["temperature"] = m.temperature
-            if m.top_p is not None:
-                kwargs["top_p"] = m.top_p
-            if m.frequency_penalty is not None:
-                kwargs["frequency_penalty"] = m.frequency_penalty
-            if m.presence_penalty is not None:
-                kwargs["presence_penalty"] = m.presence_penalty
-            if m.stop is not None:
-                kwargs["stop"] = m.stop
-        # JSON Mode
-        if cfg.ui.json_mode:
-            kwargs["response_format"] = {"type": "json_object"}
-        # 工具 + tool_choice(plan 模式强制 none)
-        if tools:
-            kwargs["tools"] = tools
-            kwargs["tool_choice"] = "none" if cfg.ui.plan_mode else "auto"
-        return kwargs
-
-    async def stream(
-        self,
-        messages: list[dict],
-        *,
-        tools: list[dict] | None = None,
-        tier: Tier | None = None,
-        thinking: bool | None = None,
-        effort: Effort | None = None,
-    ) -> AsyncIterator[StreamChunk]:
-        """流式请求,逐块产出 reasoning / content,结束时产出完整 AssistantMessage。"""
-        resolved_tier: Tier = tier or self.config.models.default_tier
-        model_id = self.config.model_id(tier)
-        kwargs = self._build_kwargs(messages, tools, tier, thinking, effort)
-
-        content = ""
-        reasoning = ""
-        tool_buf: dict[int, dict] = {}
-        usage = Usage()
-
-        try:
-            stream = await self._client.chat.completions.create(**kwargs)
-            async for chunk in stream:
-                # 用量(include_usage 时最后一块携带,choices 可能为空)
-                if getattr(chunk, "usage", None):
-                    u = chunk.usage
-                    usage = Usage(
-                        prompt_tokens=u.prompt_tokens or 0,
-                        completion_tokens=u.completion_tokens or 0,
-                        prompt_cache_hit_tokens=_extra(u, "prompt_cache_hit_tokens") or 0,
-                        prompt_cache_miss_tokens=_extra(u, "prompt_cache_miss_tokens") or 0,
-                    )
-                if not chunk.choices:
-                    continue
-                delta = chunk.choices[0].delta
-                rc = _extra(delta, "reasoning_content")
-                if rc:
-                    reasoning += rc
-                    yield StreamChunk(ChunkKind.REASONING, rc)
-                if getattr(delta, "content", None):
-                    content += delta.content
-                    yield StreamChunk(ChunkKind.CONTENT, delta.content)
-                if getattr(delta, "tool_calls", None):
-                    for tc in delta.tool_calls:
-                        slot = tool_buf.setdefault(
-                            tc.index, {"id": "", "name": "", "arguments": ""}
-                        )
-                        if tc.id:
-                            slot["id"] = tc.id
-                        fn = tc.function
-                        if fn and fn.name:
-                            slot["name"] = fn.name
-                        if fn and fn.arguments:
-                            slot["arguments"] += fn.arguments
-        except ProviderError:
-            raise
-        except Exception as exc:  # openai / 网络异常 → 统一为可读错误
-            raise ProviderError(f"DeepSeek 请求失败:{exc}") from exc
-
-        tool_calls = [
-            ToolCall(id=slot["id"], name=slot["name"], arguments=slot["arguments"])
-            for _, slot in sorted(tool_buf.items())
-            if slot["name"]
-        ]
-        message = AssistantMessage(
-            content=content,
-            reasoning_content=reasoning,
-            tool_calls=tool_calls,
-            usage=usage,
-            model=model_id,
-            tier=resolved_tier,
-        )
-        yield StreamChunk(ChunkKind.DONE, message=message)
-
-    async def complete(
-        self,
-        messages: list[dict],
-        *,
-        tools: list[dict] | None = None,
-        tier: Tier | None = None,
-        thinking: bool | None = None,
-        effort: Effort | None = None,
-    ) -> AssistantMessage:
-        """非流式便捷封装:消费整个流,返回最终消息。"""
-        final: AssistantMessage | None = None
-        async for ch in self.stream(
-            messages, tools=tools, tier=tier, thinking=thinking, effort=effort
-        ):
-            if ch.kind is ChunkKind.DONE:
-                final = ch.message
-        assert final is not None
-        return final
+"""DeepSeek V4 Provider —— 基于 OpenAI 兼容 SDK。
+
+要点(核实自 api-docs.deepseek.com):
+- 模型:deepseek-v4-flash / deepseek-v4-pro
+- 思考模式:extra_body={"thinking":{"type":"enabled"|"disabled"}} + reasoning_effort
+- 思考链走 reasoning_content(流式为 delta.reasoning_content)
+- 思考模式忽略 temperature/top_p/penalty,故思考开启时不传这些参数
+- 工具调用的回合必须回传 reasoning_content(由 Session/Agent 负责)
+- 缓存字段:usage.prompt_cache_hit_tokens / prompt_cache_miss_tokens
+"""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from openai import AsyncOpenAI
+
+from nexforge.config import Effort, NexForgeConfig, Tier
+from nexforge.core.types import (
+    AssistantMessage,
+    ChunkKind,
+    StreamChunk,
+    ToolCall,
+    Usage,
+)
+
+
+class ProviderError(RuntimeError):
+    """Provider 层的可读错误(缺 key、网络、API 报错)。"""
+
+
+def _extra(obj: Any, name: str) -> Any:
+    """从 openai 返回对象里取标准字段或 extra 字段(DeepSeek 自定义字段)。"""
+    val = getattr(obj, name, None)
+    if val is not None:
+        return val
+    extra = getattr(obj, "model_extra", None)
+    if isinstance(extra, dict):
+        return extra.get(name)
+    return None
+
+
+class DeepSeekProvider:
+    def __init__(self, config: NexForgeConfig):
+        self.config = config
+        key = config.resolve_api_key()
+        if not key:
+            raise ProviderError(
+                f"未找到 API Key。请设置环境变量 {config.provider.api_key_env},"
+                f"或在 {config.provider.base_url} 对应的 config.toml 中填写 api_key。"
+            )
+        self._client = AsyncOpenAI(
+            api_key=key,
+            base_url=config.provider.base_url,
+            timeout=config.provider.timeout,
+            max_retries=config.provider.max_retries,
+        )
+
+    async def aclose(self) -> None:
+        await self._client.close()
+
+    def _build_kwargs(
+        self,
+        messages: list[dict],
+        tools: list[dict] | None,
+        tier: Tier | None,
+        thinking: bool | None,
+        effort: Effort | None,
+    ) -> dict:
+        cfg = self.config
+        think = cfg.models.thinking if thinking is None else thinking
+        eff = effort or cfg.models.reasoning_effort
+        # DeepSeek 专有参数走 extra_body(直接进请求体顶层)
+        extra_body: dict[str, Any] = {
+            "thinking": {"type": "enabled" if think else "disabled"}
+        }
+        if think:
+            extra_body["reasoning_effort"] = eff
+
+        kwargs: dict[str, Any] = {
+            "model": cfg.model_id(tier),
+            "messages": messages,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+            "extra_body": extra_body,
+        }
+        # max_tokens vs max_completion_tokens(DeepSeek 推荐新参数)
+        if cfg.models.use_max_completion_tokens:
+            kwargs["max_completion_tokens"] = cfg.models.max_output_tokens
+        else:
+            kwargs["max_tokens"] = cfg.models.max_output_tokens
+        # 采样参数(仅 thinking=off 生效)
+        if not think:
+            m = cfg.models
+            if m.temperature is not None:
+                kwargs["temperature"] = m.temperature
+            if m.top_p is not None:
+                kwargs["top_p"] = m.top_p
+            if m.frequency_penalty is not None:
+                kwargs["frequency_penalty"] = m.frequency_penalty
+            if m.presence_penalty is not None:
+                kwargs["presence_penalty"] = m.presence_penalty
+            if m.stop is not None:
+                kwargs["stop"] = m.stop
+        # JSON Mode
+        if cfg.ui.json_mode:
+            kwargs["response_format"] = {"type": "json_object"}
+        # 工具 + tool_choice(plan 模式强制 none)
+        if tools:
+            kwargs["tools"] = tools
+            kwargs["tool_choice"] = "none" if cfg.ui.plan_mode else "auto"
+        return kwargs
+
+    async def stream(
+        self,
+        messages: list[dict],
+        *,
+        tools: list[dict] | None = None,
+        tier: Tier | None = None,
+        thinking: bool | None = None,
+        effort: Effort | None = None,
+    ) -> AsyncIterator[StreamChunk]:
+        """流式请求,逐块产出 reasoning / content,结束时产出完整 AssistantMessage。"""
+        resolved_tier: Tier = tier or self.config.models.default_tier
+        model_id = self.config.model_id(tier)
+        kwargs = self._build_kwargs(messages, tools, tier, thinking, effort)
+
+        content = ""
+        reasoning = ""
+        tool_buf: dict[int, dict] = {}
+        usage = Usage()
+
+        try:
+            stream = await self._client.chat.completions.create(**kwargs)
+            async for chunk in stream:
+                # 用量(include_usage 时最后一块携带,choices 可能为空)
+                if getattr(chunk, "usage", None):
+                    u = chunk.usage
+                    usage = Usage(
+                        prompt_tokens=u.prompt_tokens or 0,
+                        completion_tokens=u.completion_tokens or 0,
+                        prompt_cache_hit_tokens=_extra(u, "prompt_cache_hit_tokens") or 0,
+                        prompt_cache_miss_tokens=_extra(u, "prompt_cache_miss_tokens") or 0,
+                    )
+                if not chunk.choices:
+                    continue
+                delta = chunk.choices[0].delta
+                rc = _extra(delta, "reasoning_content")
+                if rc:
+                    reasoning += rc
+                    yield StreamChunk(ChunkKind.REASONING, rc)
+                if getattr(delta, "content", None):
+                    content += delta.content
+                    yield StreamChunk(ChunkKind.CONTENT, delta.content)
+                if getattr(delta, "tool_calls", None):
+                    for tc in delta.tool_calls:
+                        slot = tool_buf.setdefault(
+                            tc.index, {"id": "", "name": "", "arguments": ""}
+                        )
+                        if tc.id:
+                            slot["id"] = tc.id
+                        fn = tc.function
+                        if fn and fn.name:
+                            slot["name"] = fn.name
+                        if fn and fn.arguments:
+                            slot["arguments"] += fn.arguments
+        except ProviderError:
+            raise
+        except Exception as exc:  # openai / 网络异常 → 统一为可读错误
+            raise ProviderError(f"DeepSeek 请求失败:{exc}") from exc
+
+        tool_calls = [
+            ToolCall(id=slot["id"], name=slot["name"], arguments=slot["arguments"])
+            for _, slot in sorted(tool_buf.items())
+            if slot["name"]
+        ]
+        message = AssistantMessage(
+            content=content,
+            reasoning_content=reasoning,
+            tool_calls=tool_calls,
+            usage=usage,
+            model=model_id,
+            tier=resolved_tier,
+        )
+        yield StreamChunk(ChunkKind.DONE, message=message)
+
+    async def complete(
+        self,
+        messages: list[dict],
+        *,
+        tools: list[dict] | None = None,
+        tier: Tier | None = None,
+        thinking: bool | None = None,
+        effort: Effort | None = None,
+    ) -> AssistantMessage:
+        """非流式便捷封装:消费整个流,返回最终消息。"""
+        final: AssistantMessage | None = None
+        async for ch in self.stream(
+            messages, tools=tools, tier=tier, thinking=thinking, effort=effort
+        ):
+            if ch.kind is ChunkKind.DONE:
+                final = ch.message
+        assert final is not None
+        return final

{nexforge_cli-0.1.1 → nexforge_cli-0.2.0}/src/nexforge/store/session_store.py

@@ -192,7 +192,7 @@ def delete_session(session_id: str) -> bool:
     today = _today_dir()
     target = today / f"{session_id}.md"
     if target.exists():
-        target.unlink()
+        target.unlink(missing_ok=True)
         return True
     # 也搜其他日期目录
     proj = _sessions_dir()