sigit-code 1.5.8__tar.gz → 1.5.10__tar.gz

{sigit_code-1.5.8 → sigit_code-1.5.10}/.agents/skills/sigit-code-release/SKILL.md

@@ -35,6 +35,7 @@ Use this skill when preparing a release for this repository.
 - The crate is published to crates.io (`release-crates.yml`) and the Homebrew tap is updated (`release-homebrew.yml`) as part of the tag-driven flow. Per the siGit release flow, Homebrew is auto-triggered — do not dispatch it manually.
 - `release-github.yml` builds the binaries, attaches them (plus a `.deb`/`.rpm` per Linux target built with nfpm from `packaging/nfpm.yaml`) to the GitHub release, then dispatches `release-homebrew`, `release-scoop`, `release-winget`, and `release-aur`. A dispatch failure in any one of those four is logged as a warning, not a hard failure — an unconfigured channel doesn't block the rest of the release. `release-nuget.yml` and `release-mcp-registry.yml`, by contrast, are tag-triggered directly like the other language-registry workflows, not dispatched from `release-github.yml`.
 - Every release asset carries a `.sha256` sidecar (not just the macOS Homebrew tarball). Scoop, winget, and the AUR PKGBUILD each consume the raw binaries plus their sidecar checksum, rather than the tarball.
+- The GitHub release body is generated, not hand-written: `release-github.yml`'s release job checks out the tag, awk-extracts the `## <version>` section from `CHANGELOG.md` (a missing section is a hard failure), appends a full-changelog link and a `sigit.si/code` footnote, and publishes it via `body_path: release_notes.md`. The only file a release-prep change needs to touch is `CHANGELOG.md` — never edit release notes in the GitHub UI, because the next tag push would overwrite them.
 - npm and NuGet publish via OIDC trusted publishing — neither has a stored token in the repo. On npm this is configured per package (each `@getsigit/*` name has a trusted publisher pointing at `release-npm.yml`), so a new package needs the same setup before its first publish will work. OIDC requires npm >= 11.5.1 and Node >= 22.14.0.
 - The NuGet package (`SiGit.Code`, `dotnet tool install --global SiGit.Code`) bundles all six platform binaries under `native/<os>-<arch>/` behind a managed shim, rather than shipping one package per platform like npm/PyPI. Watch the nuget.org 250 MB package-size limit if it ever grows.
 - The baked-in official MCP server is separately listed in the public MCP Registry as `si.sigit/sigit` (`release-mcp-registry.yml`, driven by `server.json` at the repo root). It's a remote Streamable-HTTP listing, so it's verified by a DNS TXT record on the `sigit.si` domain rather than the GitHub-OIDC scheme used for package listings.

{sigit_code-1.5.8 → sigit_code-1.5.10}/.claude/skills/sigit-code-release/SKILL.md

@@ -35,6 +35,7 @@ Use this skill when preparing a release for this repository.
 - The crate is published to crates.io (`release-crates.yml`) and the Homebrew tap is updated (`release-homebrew.yml`) as part of the tag-driven flow. Per the siGit release flow, Homebrew is auto-triggered — do not dispatch it manually.
 - `release-github.yml` builds the binaries, attaches them (plus a `.deb`/`.rpm` per Linux target built with nfpm from `packaging/nfpm.yaml`) to the GitHub release, then dispatches `release-homebrew`, `release-scoop`, `release-winget`, and `release-aur`. A dispatch failure in any one of those four is logged as a warning, not a hard failure — an unconfigured channel doesn't block the rest of the release. `release-nuget.yml` and `release-mcp-registry.yml`, by contrast, are tag-triggered directly like the other language-registry workflows, not dispatched from `release-github.yml`.
 - Every release asset carries a `.sha256` sidecar (not just the macOS Homebrew tarball). Scoop, winget, and the AUR PKGBUILD each consume the raw binaries plus their sidecar checksum, rather than the tarball.
+- The GitHub release body is generated, not hand-written: `release-github.yml`'s release job checks out the tag, awk-extracts the `## <version>` section from `CHANGELOG.md` (a missing section is a hard failure), appends a full-changelog link and a `sigit.si/code` footnote, and publishes it via `body_path: release_notes.md`. The only file a release-prep change needs to touch is `CHANGELOG.md` — never edit release notes in the GitHub UI, because the next tag push would overwrite them.
 - npm and NuGet publish via OIDC trusted publishing — neither has a stored token in the repo. On npm this is configured per package (each `@getsigit/*` name has a trusted publisher pointing at `release-npm.yml`), so a new package needs the same setup before its first publish will work. OIDC requires npm >= 11.5.1 and Node >= 22.14.0.
 - The NuGet package (`SiGit.Code`, `dotnet tool install --global SiGit.Code`) bundles all six platform binaries under `native/<os>-<arch>/` behind a managed shim, rather than shipping one package per platform like npm/PyPI. Watch the nuget.org 250 MB package-size limit if it ever grows.
 - The baked-in official MCP server is separately listed in the public MCP Registry as `si.sigit/sigit` (`release-mcp-registry.yml`, driven by `server.json` at the repo root). It's a remote Streamable-HTTP listing, so it's verified by a DNS TXT record on the `sigit.si` domain rather than the GitHub-OIDC scheme used for package listings.

{sigit_code-1.5.8 → sigit_code-1.5.10}/.github/workflows/release-github.yml

@@ -240,6 +240,41 @@ jobs:
             echo "tag=${{ github.ref_name }}" >> "$GITHUB_OUTPUT"
           fi
 
+      - name: Checkout tag
+        # The release job otherwise only downloads artifacts; the changelog
+        # has to be read from the tree at the tag being released.
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ steps.tag.outputs.tag }}
+
+      - name: Compose release notes
+        # The release page carries the section of CHANGELOG.md for this
+        # version, not a bare "Full changelog" default. A missing section is
+        # a hard failure: publishing a release whose notes don't match its
+        # changelog is worse than stopping the job.
+        shell: bash
+        run: |
+          version="${{ steps.tag.outputs.tag }}"
+          version="${version#v}"
+          section="$(awk -v ver="${version}" '
+            $0 == "## " ver { found = 1; next }
+            found && /^## / { exit }
+            found { print }
+          ' CHANGELOG.md)"
+          if [ -z "${section//[$' \t\n']/}" ]; then
+            echo "No ## ${version} section found in CHANGELOG.md" >&2
+            exit 1
+          fi
+          {
+            printf '%s\n' "${section}"
+            printf '\n---\n\n'
+            printf 'Full changelog: https://github.com/%s/blob/%s/CHANGELOG.md\n' \
+              "${GITHUB_REPOSITORY}" "${{ steps.tag.outputs.tag }}"
+            printf '\n---\n\n'
+            printf 'About siGit Code: [sigit.si/code](https://sigit.si/code)\n'
+          } > release_notes.md
+          cat release_notes.md
+
       - name: Download binary artifacts
         uses: actions/download-artifact@v4
         with:
@@ -258,6 +293,7 @@ jobs:
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ steps.tag.outputs.tag }}
+          body_path: release_notes.md
           files: release/*
 
       # These channels all publish somewhere outside this repo (a tap, a Scoop

{sigit_code-1.5.8 → sigit_code-1.5.10}/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 1.5.10
+
+### What changed
+
+- **Xcode's context no longer buries slash commands.** Xcode sends the user's
+  prompt as the last of several text blocks, with project context in the
+  blocks before it, so `/models` and friends sat in the middle of joined text
+  and were handed to the model instead of dispatching locally. Slash-command
+  parsing now searches the prompt's text blocks from the end, so a standalone
+  command in the final user block dispatches no matter what context the client
+  prepends
+- **The nova tier is the default cloud engine.** When local inference is off
+  and no explicit provider override is set, the cloud tier now defaults to
+  `nova` (the `onde-nova` model) instead of the balanced tier, in both the
+  interactive and headless paths
+
+### Fixed
+
+- **Malformed Chinese-model tool calls are handled end-to-end in ACP.** The
+  inline-call recovery that 1.5.9 added for Kimi K3's XTML protocol and GLM's
+  mis-tagged blocks only applied to the interactive and headless surfaces;
+  the ACP path never ran it, so an editor session still surfaced raw protocol
+  text and dropped the calls. Recovery now runs in the ACP prompt loop too,
+  covered by integration tests, and the tool names are checked against the
+  turn's offered tools before anything executes
+- **Suppressed tool-call log spam is gone.** The guard that logs when a
+  structured call is dropped for arriving as forced text fired once per
+  streamed argument fragment — one malformed call could log a warning per
+  chunk. The check now fires once per turn with the count and names of what
+  was dropped, and the non-streaming path reports the same
+- **A history-replay test no longer races on the process cwd.** One ACP test
+  built its expected path from `std::env::current_dir()` while other tests
+  briefly swap that process-global cwd, so on CI it could read a temp
+  directory mid-swap and compare a truncated title against an untruncated
+  expectation. It now uses a fixed path it never needed to derive
+
+## 1.5.9
+
+### Fixed
+
+- **Kimi K3 tool calls no longer arrive as raw protocol text.** Kimi K3 renders
+  a call in Moonshot's XTML protocol — pipe-delimited open/sep/close tokens
+  wrapping named blocks — and when the serving stack doesn't parse that back
+  into structured tool calls, the whole block surfaced in the editor as literal
+  text and the turn ended as though the model had answered in prose. The
+  inline-call recovery now speaks that protocol alongside the legacy XML tags:
+  tools blocks are parsed into real calls (several per block, argument values
+  decoded and typed from the block's own type attribute or, when it is
+  missing, the turn's tool schemas), response blocks are unwrapped so their
+  text still renders, and think blocks are dropped as private reasoning rather
+  than shown. The streaming scanner watches all the opening markers, so a
+  block split across chunk boundaries still recovers
+- **GLM's mis-tagged calls recover too.** GLM sometimes precedes the legacy
+  block's first argument key with another tool-call opening tag instead of the
+  arg-key opening tag the format calls for, and the recovery rejected the
+  whole block when it did — the call surfaced as text and whatever it was
+  trying to do was dropped. The parser now accepts that alias for the first
+  argument only — later arguments stay strict, so text that merely resembles a
+  call cannot be recovered as one — in both the whole-blob and streaming
+  paths, and the scanner tolerates the malformed marker split across chunk
+  boundaries. Recovery in both protocols also checks the call's name against
+  the tools actually offered in the turn: a tag naming a tool that was never
+  in the turn's spec stays on screen instead of being executed
+
 ## 1.5.8
 
 ### What changed

{sigit_code-1.5.8 → sigit_code-1.5.10}/Cargo.lock

@@ -5778,7 +5778,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.5.8"
+version = "1.5.10"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.5.8 → sigit_code-1.5.10}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sigit"
-version = "1.5.8"
+version = "1.5.10"
 edition = "2024"
 description = "siGit Code — ACP-compatible AI coding agent. Sí, git."
 documentation = "https://github.com/getsigit/sigit"

{sigit_code-1.5.8 → sigit_code-1.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.5.8
+Version: 1.5.10
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{sigit_code-1.5.8 → sigit_code-1.5.10}/src/backend.rs

@@ -159,12 +159,15 @@ pub trait InferenceBackend: Send + Sync {
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError>;
 
-    /// Continue the turn by returning tool results. `tools` may be `None` on the
-    /// final round to force a text answer. `sink` streams that text when set.
+    /// Continue the turn by returning tool results. `allow_tool_calls` controls
+    /// whether `tools` are offered again; the complete catalog remains available
+    /// so a disabled round can recognize and suppress tool-shaped model output.
+    /// `sink` streams assistant text when set.
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError>;
 
@@ -257,7 +260,8 @@ impl InferenceBackend for LocalBackend {
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         let onde_results: Vec<onde::inference::ToolResult> = results
@@ -268,10 +272,10 @@ impl InferenceBackend for LocalBackend {
             })
             .collect();
 
-        // The final round passes `tools = None` to force a text answer; that's
-        // the only round onde can stream, since no further tool calls are parsed.
+        // A forced-text round is the only round onde can stream, since no
+        // further tool calls are parsed.
         if let Some(sink) = sink
-            && tools.is_none()
+            && !allow_tool_calls
         {
             let rx = self
                 .engine
@@ -281,7 +285,7 @@ impl InferenceBackend for LocalBackend {
             return drain_onde_stream(rx, sink).await;
         }
 
-        let onde_tools = tools.map(to_onde_tools);
+        let onde_tools = allow_tool_calls.then(|| to_onde_tools(tools));
         let result = self
             .engine
             .send_tool_results(onde_results, onde_tools.as_deref())
@@ -485,12 +489,14 @@ impl OpenAiBackend {
             .collect()
     }
 
-    /// POST the current history (plus `tools`) and apply the assistant reply to
-    /// history, returning the neutral turn result. Streams via SSE when `sink`
-    /// is set; otherwise reads a single JSON response.
+    /// POST the current history and apply the assistant reply to history.
+    /// `tools` is always the known catalog, while `allow_tool_calls` determines
+    /// whether it is advertised to the model and whether returned calls may run.
+    /// Streams via SSE when `sink` is set; otherwise reads a single JSON response.
     async fn complete(
         &self,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
@@ -501,9 +507,7 @@ impl OpenAiBackend {
             "messages": *self.history.lock().await,
             "stream": streaming,
         });
-        if let Some(tools) = tools
-            && !tools.is_empty()
-        {
+        if allow_tool_calls && !tools.is_empty() {
             body["tools"] = serde_json::Value::Array(Self::tools_json(tools));
             // OpenAI specifies `auto` as the default when tools are present,
             // but not every OpenAI-compatible gateway implements that default.
@@ -528,13 +532,11 @@ impl OpenAiBackend {
             return Err(describe_api_error(status, &body));
         }
 
-        // The specs are needed downstream to type the arguments of any tool
-        // call the model emitted as text rather than as a structured call.
-        let tools = tools.unwrap_or(&[]);
         if let Some(sink) = sink {
-            self.consume_stream(response, sink, tools).await
+            self.consume_stream(response, sink, tools, allow_tool_calls)
+                .await
         } else {
-            self.consume_json(response, tools).await
+            self.consume_json(response, tools, allow_tool_calls).await
         }
     }
 
@@ -543,6 +545,7 @@ impl OpenAiBackend {
         &self,
         response: reqwest::Response,
         tools: &[ToolSpec],
+        allow_tool_calls: bool,
     ) -> Result<TurnResult, BackendError> {
         let parsed: ChatCompletion = response
             .json()
@@ -556,7 +559,7 @@ impl OpenAiBackend {
             .map(|choice| choice.message)
             .ok_or_else(|| "endpoint returned no choices".to_string())?;
 
-        let text = message.content.clone().unwrap_or_default();
+        let mut text = message.content.clone().unwrap_or_default();
         let tool_calls: Vec<ToolCall> = message
             .tool_calls
             .iter()
@@ -568,6 +571,31 @@ impl OpenAiBackend {
             })
             .collect();
 
+        if !allow_tool_calls {
+            let (cleaned, recovered) = crate::inline_tool_calls::extract(&text, tools);
+            text = cleaned;
+            let suppressed = tool_calls.len() + recovered.len();
+            if suppressed > 0 {
+                let names = tool_calls
+                    .iter()
+                    .map(|call| call.name.as_str())
+                    .chain(recovered.iter().map(|call| call.name.as_str()))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                log::warn!(
+                    "suppressed {suppressed} tool call(s) from a forced-text response: {names}"
+                );
+            }
+            self.history
+                .lock()
+                .await
+                .push(streamed_assistant_history(&text, &[]));
+            return Ok(TurnResult {
+                text,
+                tool_calls: Vec::new(),
+            });
+        }
+
         // Some models write a tool call out as literal `<tool_call>` text
         // instead of using the structured field (see `inline_tool_calls`).
         // Recover it, or the turn ends with the tag rendered as prose and
@@ -617,6 +645,7 @@ impl OpenAiBackend {
         response: reqwest::Response,
         sink: &TokenSink,
         tools: &[ToolSpec],
+        allow_tool_calls: bool,
     ) -> Result<TurnResult, BackendError> {
         use futures::StreamExt;
 
@@ -691,10 +720,12 @@ impl OpenAiBackend {
                                 }
                             }
                             crate::inline_tool_calls::ScanEvent::ToolCall(call) => {
-                                log::warn!(
-                                    "recovered tool call '{}' the model emitted as text instead of a structured call",
-                                    call.name
-                                );
+                                if allow_tool_calls {
+                                    log::warn!(
+                                        "recovered tool call '{}' the model emitted as text instead of a structured call",
+                                        call.name
+                                    );
+                                }
                                 recovered.push(ToolCall {
                                     id: format!("call_recovered_{}", recovered.len()),
                                     name: call.name,
@@ -755,6 +786,19 @@ impl OpenAiBackend {
             .collect();
         tool_calls.extend(recovered);
 
+        if !allow_tool_calls && !tool_calls.is_empty() {
+            let names = tool_calls
+                .iter()
+                .map(|call| call.name.as_str())
+                .collect::<Vec<_>>()
+                .join(", ");
+            log::warn!(
+                "suppressed {} tool call(s) from a forced-text response: {names}",
+                tool_calls.len()
+            );
+            tool_calls.clear();
+        }
+
         // Record the assistant turn so later tool results have context.
         self.history
             .lock()
@@ -813,13 +857,14 @@ impl InferenceBackend for OpenAiBackend {
             .lock()
             .await
             .push(serde_json::json!({ "role": "user", "content": text }));
-        self.complete(Some(tools), sink).await
+        self.complete(tools, true, sink).await
     }
 
     async fn send_tool_results(
         &self,
         results: Vec<ToolResult>,
-        tools: Option<&[ToolSpec]>,
+        tools: &[ToolSpec],
+        allow_tool_calls: bool,
         sink: Option<&TokenSink>,
     ) -> Result<TurnResult, BackendError> {
         {
@@ -832,7 +877,7 @@ impl InferenceBackend for OpenAiBackend {
                 }));
             }
         }
-        self.complete(tools, sink).await
+        self.complete(tools, allow_tool_calls, sink).await
     }
 
     async fn record_cancelled_tool_results(&self, results: Vec<ToolResult>) {
@@ -887,7 +932,7 @@ impl InferenceBackend for OpenAiBackend {
         }));
         *self.history.lock().await = request;
 
-        let summary = match self.complete(None, None).await {
+        let summary = match self.complete(&[], false, None).await {
             Ok(result) => result.text,
             Err(error) => {
                 // Roll back the summarization request; the turn never happened.

{sigit_code-1.5.8 → sigit_code-1.5.10}/src/chat.rs

@@ -3346,12 +3346,8 @@ mod tui {
 
             // on the last round, pass no tools so the model must produce text —
             // that's also the round we can stream on-device.
-            let next_tools = if round < MAX_TOOL_ROUNDS {
-                Some(tools.as_slice())
-            } else {
-                None
-            };
-            let sink = if next_tools.is_none() {
+            let allow_tool_calls = round < MAX_TOOL_ROUNDS;
+            let sink = if !allow_tool_calls {
                 streamed = true;
                 Some(&delta_tx)
             } else {
@@ -3359,7 +3355,7 @@ mod tui {
             };
 
             match backend
-                .send_tool_results(tool_results, next_tools, sink)
+                .send_tool_results(tool_results, &tools, allow_tool_calls, sink)
                 .await
             {
                 Ok(r) => result = r,

{sigit_code-1.5.8 → sigit_code-1.5.10}/src/headless.rs

@@ -170,7 +170,7 @@ pub async fn run(config: HeadlessConfig) -> i32 {
         if settings::local_inference_enabled() {
             None
         } else {
-            provider::cloud_tier_provider("balanced")
+            provider::cloud_tier_provider(provider::DEFAULT_CLOUD_TIER)
         }
     });
     let Some(cfg) = provider_cfg else {
@@ -304,18 +304,14 @@ async fn run_prompt(
             });
         }
 
-        let next_tools = if round < crate::MAX_TOOL_ROUNDS {
-            Some(tools.as_slice())
-        } else {
-            None // last round: force text
-        };
+        let allow_tool_calls = round < crate::MAX_TOOL_ROUNDS;
 
         // Whatever this round says starts a new paragraph rather than
         // continuing the sentence the tool calls interrupted.
         reply.interrupt();
 
         result = drain_to_stdout(
-            backend.send_tool_results(tool_results, next_tools, sink_opt),
+            backend.send_tool_results(tool_results, &tools, allow_tool_calls, sink_opt),
             &mut sink_rx,
             &mut reply,
         )