sigit-code 0.1.1__tar.gz → 0.1.2__tar.gz

sigit_code-0.1.2/.agents/skills/tool-calling/SKILL.md

@@ -0,0 +1,290 @@
+# Skill: Tool Calling in siGit Code
+
+## Overview
+
+siGit Code supports **agentic tool calling** — the LLM invokes tools (read/write files, run commands, read websites) to operate on the user's codebase. This works in both **interactive TUI mode** and **ACP server mode** (Zed editor).
+
+Tool calling spans three layers:
+
+```
+siGit (agent loop + tool execution)
+  → onde (ChatEngine with tool-aware API)
+    → mistral.rs (model inference + tool call parsing)
+```
+
+---
+
+## Model Requirement
+
+**Only Qwen 3 supports tool calling.** Qwen 2.5 does NOT — mistral.rs only has a parser for Qwen 3's `<tool_call>...</tool_call>` XML format.
+
+| Model | Constructor | Size | Tool calling | Default |
+|-------|-----------|------|:---:|:---:|
+| Qwen 3 8B (Q4_K_M) | `GgufModelConfig::qwen3_8b()` | ~5 GB | ✅ | ✅ **default** |
+| Qwen 3 4B (Q4_K_M) | `GgufModelConfig::qwen3_4b()` | ~2.7 GB | ✅ | |
+| Qwen 3 1.7B (Q4_K_M) | `GgufModelConfig::qwen3_1_7b()` | ~1.3 GB | ✅ | |
+| Qwen 2.5 Coder 3B | `GgufModelConfig::qwen25_coder_3b()` | ~1.93 GB | ❌ | |
+| Qwen 2.5 Coder 1.5B | `GgufModelConfig::qwen25_coder_1_5b()` | ~941 MB | ❌ | |
+
+siGit uses **Qwen 3 8B** by default with `max_tokens: 8192` (set in `main.rs` for both TUI and ACP modes).
+
+### Why 8B over 4B
+
+4B can't do `edit_file` reliably. It reads a file, then fails to reproduce the exact `old_text` it just saw. This spirals into 7+ retry rounds that burn through `max_tokens` on `<think>` blocks and return nothing. 8B is the smallest model that actually lands edits.
+
+### bartowski GGUF naming convention
+
+bartowski's repos use the publisher name as a prefix with an underscore:
+
+| Constant | Value |
+|----------|-------|
+| `BARTOWSKI_QWEN3_8B_GGUF` | `"bartowski/Qwen_Qwen3-8B-GGUF"` |
+| `QWEN3_8B_GGUF_FILE` | `"Qwen_Qwen3-8B-Q4_K_M.gguf"` |
+| `BARTOWSKI_QWEN3_4B_GGUF` | `"bartowski/Qwen_Qwen3-4B-GGUF"` |
+| `QWEN3_4B_GGUF_FILE` | `"Qwen_Qwen3-4B-Q4_K_M.gguf"` |
+
+These constants live in `onde/src/inference/models.rs`.
+
+---
+
+## Tools (9 total)
+
+Defined in `sigit/src/tools.rs` via `all_tools()`:
+
+| # | Tool | Parameters | Behavior |
+|---|------|-----------|----------|
+| 1 | `read_file` | `path` | Reads file contents, truncates at 10,000 chars |
+| 2 | `create_directory` | `path` | Creates directory and all parents |
+| 3 | `list_directory` | `path` | Lists entries with `[DIR]`/`[FILE]` prefix, dirs first |
+| 4 | `search_files` | `pattern`, `path` (optional) | Recursive regex search, max 50 matches |
+| 5 | `read_website` | `url` | Fetches HTTP/HTTPS, strips HTML, returns text |
+| 6 | `create_file` | `path`, `content` | Creates new file (fails if exists) |
+| 7 | `edit_file` | `path`, `old_text`, `new_text` | Find-and-replace (must match exactly once) |
+| 8 | `delete_file` | `path` | Deletes file or empty directory |
+| 9 | `run_command` | `command`, `cwd` (optional) | Shell command with 120s timeout |
+
+### Async handling
+
+`execute_tool()` is `async`. Most tools run synchronously, except:
+
+- **`read_website`** — uses `tokio::task::spawn_blocking` because `reqwest::blocking::Client` panics inside a tokio runtime ("Cannot start a runtime from within a runtime")
+
+### Tool gating by model
+
+In TUI mode, `run_inference_task()` takes a `tools_enabled: bool` parameter. When the model's `ModelOption.tool_calling` is `false` (Qwen 2.5), an empty tool list is passed so the model doesn't receive tool schemas it can't use.
+
+---
+
+## Architecture
+
+### Layer 1: mistral.rs (model-level)
+
+- `RequestBuilder::set_tools(Vec<Tool>)` — attach tool definitions
+- `RequestBuilder::set_tool_choice(ToolChoice::Auto)` — let model decide
+- `QwenParser` detects `<tool_call>...</tool_call>` tags in output
+- Grammar-constrained decoding forces valid JSON inside tool calls
+- `<think>...</think>` reasoning is separated from tool calls by the reasoning parser
+- Works identically for GGUF and full-precision models
+
+### Layer 2: onde (engine-level)
+
+#### Key types (`onde/src/inference/types.rs`)
+
+| Type | Purpose |
+|------|---------|
+| `ToolDefinition` | `{ name, description, parameters_schema: String }` |
+| `ToolCallRequest` | `{ id, function_name, arguments: String }` |
+| `ToolResult` | `{ tool_call_id, content: String }` |
+| `ToolAwareResult` | `{ text, tool_calls: Vec<ToolCallRequest>, duration_secs, ... }` |
+
+#### Key methods (`onde/src/inference/engine.rs`)
+
+| Method | Purpose |
+|--------|---------|
+| `send_message_with_tools(msg, &[ToolDefinition])` | Returns `ToolAwareResult` with possible tool calls |
+| `send_tool_results(Vec<ToolResult>, Option<&[ToolDefinition]>)` | Feed results back; `None` forces text response |
+
+#### Internal details
+
+- `attach_tools()` converts `ToolDefinition` → mistral.rs `Tool`, sets `ToolChoice::Auto` and `strict: Some(true)`
+- `parse_tool_calls()` extracts tool calls from `choice.message.tool_calls`, generates fallback IDs if empty
+- `replay_history_with_tools()` uses `.enumerate()` for correct sequential `index` values
+- Malformed `parameters_schema` JSON logs a warning instead of silently producing empty params
+- Malformed tool call `arguments` JSON logs a warning for debugging
+
+### Layer 3: siGit (agent-level)
+
+#### ACP session handling (`src/main.rs`)
+
+All session handlers (`load_session`, `fork_session`, `new_session`) do:
+
+1. **Store `args.cwd`** in `session_cwd: Mutex<Option<PathBuf>>`
+2. **`std::env::set_current_dir(&args.cwd)`** — so relative paths in tool calls resolve correctly
+3. **`engine.clear_history()`** — siGit doesn't persist sessions
+4. **`engine.push_history(ChatMessage::system(...))`** — injects: *"The user's project working directory is {cwd}. Always use absolute paths..."*
+
+Without step 4, the model uses the process `cwd` (often `$HOME`) and creates files in the wrong directory.
+
+#### ACP content block handling (`prompt()`)
+
+The `prompt()` handler processes all ACP content block types:
+
+- **`ContentBlock::Text`** — passed through as-is
+- **`ContentBlock::Resource` (EmbeddedResource)** — `TextResourceContents` inlined as `--- {uri} ---\n{text}\n--- end ---`
+- **`ContentBlock::ResourceLink`** — `file://` URIs are read from disk. **Line range fragments** like `#L207:219` are parsed: the `#` fragment is stripped from the path, and only lines 207–219 are extracted and sent to the model
+
+Example: Zed sends `@ index.html (207:219)` as:
+```
+ResourceLink(name="index.html (207:219)", uri="file:///path/to/index.html#L207:219")
+```
+siGit parses this into path `/path/to/index.html` + lines 207–219.
+
+---
+
+## The Agentic Loop
+
+Both ACP mode (`SiGitAgent::prompt()`) and TUI mode (`run_inference_task()`) implement:
+
+```
+1. engine.send_message_with_tools(user_text, &tools) → ToolAwareResult
+2. while result.tool_calls is non-empty AND round < MAX_TOOL_ROUNDS (10):
+   a. For each tool_call:
+      - Log: → tool_name(arguments)
+      - Execute: tools::execute_tool(name, arguments).await
+      - Log: ← N chars
+      - Collect ToolResult { tool_call_id, content }
+   b. Decide next_tools:
+      - round < MAX_TOOL_ROUNDS → Some(&tools)  (allow more calls)
+      - else → None  (force text response)
+   c. engine.send_tool_results(results, next_tools) → ToolAwareResult
+3. Send final result.text to user
+   - Empty reply after tool rounds → log warning (ACP) or show error (TUI)
+```
+
+---
+
+## System Prompt
+
+The `SYSTEM_PROMPT` in `main.rs` (~122 lines) includes critical instructions:
+
+- **Never tell the user to run commands** — use `run_command` tool instead
+- **Can access websites** — use `read_website` tool (overrides RLHF refusal training)
+- **Prefer absolute paths** in all tool arguments
+- **Git operations** — always use `run_command` with absolute cwd
+- **smbCloud domain knowledge** — auth boundaries, deploy flows, project structure
+
+The session `cwd` is injected as a separate system message at session creation time (not part of the static prompt).
+
+---
+
+## Model Cache
+
+Models are stored in the shared Onde App Group container on macOS:
+
+```
+~/Library/Group Containers/group.com.ondeinference.apps/models/hub/
+```
+
+`setup.rs` sets `HF_HOME` and `HF_HUB_CACHE` to point there at startup, so siGit reuses models downloaded by the Onde desktop app (and vice versa).
+
+---
+
+## Adding a New Tool
+
+1. Add an `AgentTool` entry to `all_tools()` in `src/tools.rs`
+2. Add a match arm to `execute_tool()` — use `spawn_blocking` if the implementation blocks
+3. Write `exec_your_tool(arguments: &str) -> String`
+4. Update `test_all_tools_count` test (currently expects 9)
+
+No changes needed in onde or mistral.rs — tool definitions are passed dynamically.
+
+---
+
+## Adding a New Model
+
+1. **`onde/src/inference/models.rs`** — add `pub const` for repo ID and GGUF filename, add to `SUPPORTED_MODELS` array and `SUPPORTED_MODEL_INFO`
+2. **`onde/src/inference/engine.rs`** — add `pub fn model_name() -> Self` constructor to `impl GgufModelConfig`
+3. **`sigit/src/chat.rs`** — add `ModelOption` entry to `SIGIT_MODELS` with `tool_calling: true/false`
+4. **`sigit/src/main.rs`** — update `run_interactive()` and `run_acp_server()` if changing the default
+
+---
+
+## Debugging
+
+### Log locations
+
+- **TUI mode:** `$TMPDIR/sigit.log` (e.g. `/var/folders/.../sigit.log`)
+- **ACP mode (Zed):** `~/Library/Logs/Zed/Zed.log` — grep for `agent stderr:.*sigit`
+
+### Key log patterns
+
+```
+# Model loaded successfully
+ChatEngine: model Qwen 3 8B loaded in 6.9s
+
+# Session cwd captured
+load_session: id=..., cwd=/path/to/project, additional_directories=[...]
+
+# Tool call parsed by mistral.rs
+ChatEngine: tool inference END — 12.3s — tool_calls: 1
+
+# Tool executed
+→ read_file({"path":"/absolute/path/to/file.rs"})
+← 6506 chars
+
+# Tool result sent back
+ChatEngine: tool results inference START — 1 results
+
+# Model returned empty (exhausted max_tokens on thinking)
+model returned empty reply after 7 tool round(s)
+
+# ResourceLink received from Zed
+block[1]: ResourceLink(name=index.html (207:219), uri=file:///path/to/index.html#L207:219)
+
+# ResourceLink read failed (fragment not stripped — old bug, now fixed)
+could not read ResourceLink file:///path/to/index.html#L207:219: No such file or directory
+```
+
+### Common issues
+
+| Symptom | Cause | Fix |
+|---------|-------|-----|
+| Model says "I cannot access websites" | RLHF refusal override not in system prompt | System prompt now has CRITICAL block about `read_website` |
+| `0 tool call(s)` for every prompt | Wrong model loaded (Qwen 2.5) | Check log for `loading GGUF model` — must be Qwen 3 |
+| `edit_file` returns `← 161 chars` repeatedly | `old_text not found` — model can't match exact text | Use Qwen 3 8B (not 4B); consider line-based edit tool |
+| Files created in wrong directory | `cwd` not captured from ACP session | Session handlers must call `set_current_dir` + `push_history` with cwd |
+| `@ file.html (207:219)` context missing | `#L207:219` fragment not stripped from file path | `prompt()` now parses URI fragments and extracts line ranges |
+| `read_website` panics/hangs | `reqwest::blocking` inside tokio runtime | `exec_read_website` wrapped in `spawn_blocking` |
+| Empty reply after many tool rounds | Model exhausted `max_tokens` on `<think>` blocks | Set `max_tokens: 8192`; 8B model wastes fewer tokens on thinking |
+
+---
+
+## Cargo Dependency Note
+
+For local development, `sigit/Cargo.toml` must use the path dependency:
+
+```toml
+onde = { path = "../onde" }
+```
+
+For CI/release, switch to the git dependency (after pushing Onde changes):
+
+```toml
+onde = { git = "https://github.com/ondeinference/onde", branch = "development" }
+```
+
+The `qwen3_8b()` constructor only exists in the local Onde SDK until it's pushed to the `development` branch.
+
+---
+
+## File Map
+
+| File | What it does |
+|------|-------------|
+| `sigit/src/tools.rs` | 9 tool schemas (`all_tools()`), `execute_tool()` dispatch, all `exec_*` implementations |
+| `sigit/src/main.rs` | `SYSTEM_PROMPT`, `SiGitAgent` struct with `session_cwd`, ACP session handlers (cwd + push_history), `prompt()` with content block parsing, model selection (`qwen3_8b`), `MAX_TOOL_ROUNDS` |
+| `sigit/src/chat.rs` | `SIGIT_MODELS` array (4 models), `run_inference_task()` with `tools_enabled` gate, TUI tool loop |
+| `sigit/src/setup.rs` | HF cache setup pointing to shared App Group container |
+| `onde/src/inference/types.rs` | `ToolDefinition`, `ToolCallRequest`, `ToolResult`, `ToolAwareResult` |
+| `onde/src/inference/engine.rs` | `send_message_with_tools()`, `send_tool_results()`, `attach_tools()`, `parse_tool_calls()`, `replay_history_with_tools()`, `GgufModelConfig::qwen3_8b()` |
+| `onde/src/inference/models.rs` | Model constants and `SUPPORTED_MODELS` array |

{sigit_code-0.1.1 → sigit_code-0.1.2}/.github/workflows/release-homebrew.yml

@@ -54,7 +54,7 @@ jobs:
       - name: Checkout Homebrew tap
         uses: actions/checkout@v6
         with:
-          repository: getsigit/sigit-homebrew-tap
+          repository: getsigit/homebrew-tap
           token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
           path: homebrew-tap
 

{sigit_code-0.1.1 → sigit_code-0.1.2}/Cargo.lock

@@ -741,9 +741,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.60"
+version = "1.2.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
+checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1264,9 +1264,9 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.10.0"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
 
 [[package]]
 name = "defmac"
@@ -3799,7 +3799,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 [[package]]
 name = "onde"
 version = "0.1.8"
-source = "git+https://github.com/ondeinference/onde?branch=development#f0bb0daad7fb07af951002f1bcae16fbd0bc876d"
+source = "git+https://github.com/ondeinference/onde?branch=development#8321bc566cfbca8ff1d4b71f187f2b007fd98433"
 dependencies = [
  "anyhow",
  "cc",
@@ -4807,9 +4807,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.14.0"
+version = "1.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
 dependencies = [
  "web-time",
  "zeroize",
@@ -5271,7 +5271,7 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "sigit"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "agent-client-protocol",
  "anyhow",
@@ -5283,6 +5283,7 @@ dependencies = [
  "onde",
  "ratatui",
  "regex",
+ "reqwest 0.12.28",
  "serde_json",
  "tokio",
  "tokio-util",

{sigit_code-0.1.1 → sigit_code-0.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sigit"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 description = "siGit Code — ACP-compatible AI coding agent for smbCloud platform."
 documentation = "https://github.com/getsigit/sigit"
@@ -18,10 +18,10 @@ path = "src/main.rs"
 
 [dependencies]
 # ACP protocol SDK
-agent-client-protocol = { version = "0.10.4", features = ["unstable_session_fork"] }
+agent-client-protocol = { version = "0.10.4", features = ["unstable_session_fork", "unstable_session_additional_directories"] }
 
 # Onde Inference engine (local LLM)
-# For local development: onde = { path = "../onde" }
+# onde = { path = "../onde" }
 onde = { git = "https://github.com/ondeinference/onde", branch = "development" }
 
 # Async runtime
@@ -41,4 +41,5 @@ log = "0.4"
 tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
 serde_json = "1"
 regex = "1"
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls"] }
 uuid = { version = "1", features = ["v4"] }

{sigit_code-0.1.1 → sigit_code-0.1.2}/PKG-INFO

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

{sigit_code-0.1.1 → sigit_code-0.1.2}/README.md

@@ -4,6 +4,8 @@
 
 A coding agent for [smbCloud](https://smbcloud.xyz/) that runs entirely on your machine. No API keys. No cloud round-trips. The model lives in your local HuggingFace cache.
 
+siGit is meant to be a general coding agent, but it is especially good in smbCloud codebases. It already knows the rough shape of the platform: Rust workspaces with focused crates, Rails services, deploy flows, auth boundaries, and platform-managed services like GresIQ. In smbCloud repos, that means it can usually give more grounded answers with less back-and-forth.
+
 siGit has two modes:
 
 - ACP mode, where Zed or another ACP-compatible editor starts it over stdio
@@ -15,6 +17,17 @@ Current platform support:
 - Linux: ACP mode and interactive terminal mode
 - Windows: ACP mode only for now
 
+## What siGit knows about smbCloud
+
+When siGit is working in an smbCloud repo, it should lean on platform context instead of treating everything like a generic cloud app. That includes things like:
+
+- the difference between platform user flows and tenant app auth flows
+- the fact that `Project` is the umbrella workspace, while app-like resources such as `FrontendApp`, `AuthApp`, and GresIQ are separate deployable units
+- the fact that Next.js SSR deploys are not the same as the generic git-push path
+- the fact that smbCloud repos usually prefer existing workspace patterns and crate boundaries over new abstractions
+
+Outside smbCloud, it should still behave like a normal coding agent and not force platform-specific advice where it does not belong.
+
 ## Install
 
 ```sh

{sigit_code-0.1.1 → sigit_code-0.1.2}/src/chat.rs

@@ -120,6 +120,8 @@ struct App {
     load_start: Instant,
     /// Display name of the model being loaded (shown in the spinner line).
     load_model_name: String,
+    /// Whether the currently loaded model supports tool calling.
+    tool_calling: bool,
 }
 
 const BANNER_ART: &str = "\
@@ -142,6 +144,11 @@ const THINKING_FRAMES: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "
 
 impl App {
     fn new(load_model_name: String) -> Self {
+        let tool_calling = SIGIT_MODELS
+            .iter()
+            .find(|m| m.name == load_model_name)
+            .map(|m| m.tool_calling)
+            .unwrap_or(true);
         Self {
             messages: Vec::new(),
             input: String::new(),
@@ -160,6 +167,7 @@ impl App {
             load_error: None,
             load_start: Instant::now(),
             load_model_name,
+            tool_calling,
         }
     }
 
@@ -303,6 +311,13 @@ struct ModelOption {
 }
 
 const SIGIT_MODELS: &[ModelOption] = &[
+    ModelOption {
+        name: "Qwen 3 8B (Q4_K_M)",
+        description: "~5 GB",
+        tool_calling: true,
+        max_tokens: 4096,
+        config_fn: GgufModelConfig::qwen3_8b,
+    },
     ModelOption {
         name: "Qwen 3 4B (Q4_K_M)",
         description: "~2.7 GB",
@@ -840,6 +855,7 @@ async fn exec_slash<B: ratatui::backend::Backend>(
                         match engine.load_gguf_model(config, None, Some(sampling)).await {
                             Ok(_) => {
                                 engine.clear_history().await;
+                                app.tool_calling = model.tool_calling;
                                 app.messages.push(ChatMessage::system(format!(
                                     "✓ Switched to {}",
                                     model.name
@@ -892,8 +908,13 @@ async fn run_inference_task(
     engine: Arc<ChatEngine>,
     text: String,
     tx: mpsc::Sender<InferenceUpdate>,
+    tools_enabled: bool,
 ) {
-    let onde_tools = build_onde_tools();
+    let onde_tools = if tools_enabled {
+        build_onde_tools()
+    } else {
+        vec![]
+    };
 
     let mut result = match engine.send_message_with_tools(&text, &onde_tools).await {
         Ok(r) => r,
@@ -923,8 +944,8 @@ async fn run_inference_task(
                 .send(InferenceUpdate::ToolUse(tc.function_name.clone()))
                 .await;
 
-            // Execute the tool (synchronous / blocking-ok for file I/O).
-            let output = crate::tools::execute_tool(&tc.function_name, &tc.arguments);
+            // Execute the tool (async — read_website uses spawn_blocking internally).
+            let output = crate::tools::execute_tool(&tc.function_name, &tc.arguments).await;
             log::info!("  ← {} chars", output.len());
 
             tool_results.push(ToolResult {
@@ -985,7 +1006,7 @@ pub async fn run_with<B: ratatui::backend::Backend>(
     engine: Arc<ChatEngine>,
     load_rx: std_mpsc::Receiver<Result<(), String>>,
 ) -> Result<()> {
-    let config = GgufModelConfig::platform_default();
+    let config = GgufModelConfig::qwen3_8b();
     let model_name = config.display_name.clone();
     event_loop(terminal, engine, load_rx, model_name).await
 }
@@ -1149,8 +1170,9 @@ async fn event_loop<B: ratatui::backend::Backend>(
 
                         let engine_handle = Arc::clone(&engine);
                         let user_text = text.clone();
+                        let tools_enabled = app.tool_calling;
                         tokio::spawn(async move {
-                            run_inference_task(engine_handle, user_text, tx).await;
+                            run_inference_task(engine_handle, user_text, tx, tools_enabled).await;
                         });
                     }
                 }