sigit-code 1.2.1__tar.gz → 1.3.0__tar.gz

{sigit_code-1.2.1 → sigit_code-1.3.0}/.agents/skills/sigit-code-release/SKILL.md

@@ -32,6 +32,18 @@ Use this skill when preparing a release for this repository.
 - Release workflows are tag-driven. `release-github.yml`, `release-npm.yml`, `release-pypi.yml`, `release-crates.yml`, and `release-homebrew.yml` all derive `RELEASE_VERSION` from a `v*.*.*` tag or a manually supplied tag input.
 - 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.
 
+## Git release flow
+
+Releases are cut from `development` and shipped on `main`. The published tags (`v1.2.0`, `v1.2.1`) point at the `main`-side merge commit, never at a release branch or at `development`. Follow this order:
+
+1. Branch `release/v<version>` off `development`.
+2. Apply the version bump and changelog edits, then commit (e.g. `Release v<version>`).
+3. Merge `release/v<version>` back into `development`.
+4. Merge `development` into `main` (commit message: `Merge development into main for v<version> release`).
+5. Tag `v<version>` on that `main` merge commit, then push `main` and the tag.
+
+Pushing the `v*.*.*` tag is what fires every release workflow, so create and push it only after the merge into `main` has landed. Do not commit, tag, or push until the user explicitly asks — confirm the version and that they want the release to go out first.
+
 ## Typical files to inspect
 
 - `Cargo.toml`
@@ -52,6 +64,7 @@ Use this skill when preparing a release for this repository.
 - `npm/sigit/package.json` is left at `0.0.0-dev` unless the packaging flow itself changed.
 - `pypi/pyproject.toml` still uses dynamic versioning unless there is a deliberate packaging change.
 - Release workflows still derive their version from the tag as expected.
+- Git flow followed: bump committed on `release/v<version>`, merged back to `development`, then `development` merged into `main`, with `v<version>` tagged on the `main` merge commit.
 - Release notes or changelog entries match the actual changes.
 - CI-equivalent local checks pass for the relevant platform or target.
 - Package names, install commands, and branding stay consistent.

sigit_code-1.3.0/.claude/skills/run-sigit/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: run-sigit
+description: Build, launch, and drive the sigit AI coding agent — run the ACP server, screenshot the interactive TUI, smoke-test the CLI. Use when asked to run sigit, start the agent, screenshot the chat UI, or verify a change to the binary.
+---
+
+# Run sigit
+
+`sigit` is a single Rust binary that picks its mode at startup from whether stdin
+is a TTY:
+
+- **ACP mode** (stdin not a TTY): newline-delimited JSON-RPC 2.0 over stdio — the
+  Agent Client Protocol surface that Zed / VS Code drive. This is the primary
+  programmatic handle. Drive it with **`.claude/skills/run-sigit/driver.mjs`**.
+- **Interactive TUI** (stdin is a TTY): a full-screen ratatui chat, Unix-only.
+  Drive it under tmux with **`.claude/skills/run-sigit/tui-smoke.sh`**.
+- **CLI subcommands**: `sigit login | logout | whoami`, handled before the split.
+
+Both drivers avoid on-device inference: `initialize`, `session/new`, and slash
+commands (`/whoami`, `/help`, `/status`) answer **without** loading a multi-GB
+GGUF model, so they work on a clean machine with nothing cached and no network.
+
+Paths below are relative to the repo root (`<unit>/`).
+
+## Prerequisites
+
+- Rust toolchain (pinned in `rust-toolchain.toml`); `cargo` on PATH.
+- Node ≥ 18 for the ACP driver (`driver.mjs`).
+- `tmux` for the TUI smoke test only: `brew install tmux` (macOS) /
+  `apt-get install -y tmux` (Linux).
+
+## Build
+
+```bash
+cargo build                 # debug binary at target/debug/sigit
+```
+
+First build is slow (it compiles `onde` / mistralrs); incremental rebuilds are
+sub-second. Use `cargo build --release` for `target/release/sigit` if you want
+realistic inference speed — the drivers default to the debug binary.
+
+## Run (agent path)
+
+### ACP server — `driver.mjs`
+
+Spawns the binary in ACP mode, runs `initialize` → `session/new` →
+`session/prompt /whoami`, prints every frame, exits 0 on success:
+
+```bash
+node .claude/skills/run-sigit/driver.mjs
+# SIGIT_BIN=target/release/sigit node .claude/skills/run-sigit/driver.mjs
+```
+
+Expected tail:
+
+```
+<-- notify session/update "Signed in to siGit Code Cloud as demo@sigit.si."
+  "stopReason": "end_turn"
+OK — ACP handshake, session, and /whoami round-tripped.
+```
+
+The `/whoami` reply arrives as an `agent_message_chunk` notification — the same
+streaming surface a real prompt fans out across many chunks. To drive real
+streamed inference, send a `session/prompt` with ordinary text instead of a
+slash command (needs a cached local model or a signed-in cloud tier).
+
+### Interactive TUI — `tui-smoke.sh`
+
+Launches the TUI under tmux, types `/help`, writes the rendered screen to
+`$TMPDIR/sigit-tui.txt` (the "screenshot" for a terminal app), then quits:
+
+```bash
+.claude/skills/run-sigit/tui-smoke.sh
+cat "${TMPDIR:-/tmp}/sigit-tui.txt"      # view the captured screen
+```
+
+To poke it by hand, the same tmux moves the script automates:
+
+```bash
+tmux new-session -d -s sigit -x 120 -y 35
+tmux send-keys -t sigit './target/debug/sigit' Enter
+sleep 6
+tmux capture-pane -t sigit -p            # read the screen
+tmux send-keys -t sigit '/help' Enter
+tmux send-keys -t sigit C-c              # Ctrl+C quits
+tmux kill-session -t sigit
+```
+
+### CLI smoke
+
+```bash
+./target/debug/sigit whoami              # prints the signed-in account, exit 0
+```
+
+## Run (human path)
+
+```bash
+cargo run                                # stdin is your TTY → launches the TUI
+```
+
+A full-screen chat opens; type a message or `/help`, Ctrl+C to quit. Useless
+headless or with stdin piped — that path falls through to ACP mode instead.
+
+## Gotchas
+
+- **The ACP server never exits on stdin EOF.** `printf '…' | sigit | head` hangs:
+  the process stays alive holding stdout open, so `head` blocks waiting for bytes
+  that only stop when you kill it. You must read the response frame and then
+  `kill` the child — that's the whole reason `driver.mjs` exists instead of a
+  one-line pipe.
+- **Piping stdin forces ACP mode.** Any non-TTY stdin (a pipe, `</dev/null`)
+  routes to the JSON-RPC server, not the TUI. The TUI needs a real PTY, hence
+  tmux.
+- **Handshake is intentionally model-free.** `initialize` / `session/new` defer
+  GGUF loading to the first real prompt, so they're fast and need no network. A
+  text `session/prompt` to an on-device model triggers a ~1–2 GB download on
+  first use.
+- **The default model depends on sign-in state.** On a signed-in machine the
+  picker shows a cloud tier (e.g. `onde-cloud (onde-fast)`); logged out it
+  defaults to an on-device model. `sigit whoami` shows which.
+- **Logs go to different places per mode.** ACP mode → stderr (the driver prefixes
+  them `[sigit]`). TUI mode redirects all stdout/stderr to `$TMPDIR/sigit.log` so
+  the ratatui surface stays clean — tail that file to debug the TUI.
+- **macOS model cache is shared with the desktop app**, under
+  `~/Library/Group Containers/group.com.ondeinference.apps/models/`; other
+  platforms use `~/.cache/huggingface/`.
+
+## Troubleshooting
+
+- `binary not found: target/debug/sigit` → run `cargo build` first.
+- Driver hangs / times out on `initialize` → you're likely running a stale binary
+  or one that crashed at startup; check the `[sigit]` stderr lines it echoes.
+- `tmux not installed` from `tui-smoke.sh` → `brew install tmux`.
+- TUI capture is blank → increase the `sleep` before `capture-pane`; the banner
+  and (lazy) model selection take a few seconds on a cold start.

sigit_code-1.3.0/.claude/skills/run-sigit/driver.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// ACP driver for the `sigit` binary.
+//
+// `sigit` runs as an Agent Client Protocol server when stdin is NOT a TTY
+// (newline-delimited JSON-RPC 2.0 over stdio — the same surface Zed / VS Code
+// drive). This script spawns the binary in that mode, runs a scripted handshake,
+// prints every request/response/notification, and exits non-zero on failure.
+//
+// It deliberately avoids triggering on-device inference: `initialize`,
+// `session/new`, and slash commands like `/whoami` and `/status` answer without
+// loading a multi-GB GGUF model, so the driver works on a clean machine with no
+// model cached and no network.
+//
+// Usage:
+//   node driver.mjs [path-to-binary]      # default: target/debug/sigit
+//   SIGIT_BIN=target/release/sigit node driver.mjs
+//
+// Exit code 0 = every step got a well-formed JSON-RPC result.
+
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { existsSync } from "node:fs";
+
+const bin = process.argv[2] || process.env.SIGIT_BIN || "target/debug/sigit";
+if (!existsSync(bin)) {
+  console.error(`binary not found: ${bin} — run \`cargo build\` first`);
+  process.exit(2);
+}
+
+// Force ACP mode regardless of how the driver itself was launched: pipe stdin so
+// the child's stdin is not a TTY.
+const child = spawn(bin, [], { stdio: ["pipe", "pipe", "pipe"] });
+
+// Surface the agent's own logs (it writes them to stderr in ACP mode).
+createInterface({ input: child.stderr }).on("line", (l) =>
+  console.error(`[sigit] ${l}`),
+);
+
+const pending = new Map(); // id -> {resolve, method}
+const notifications = [];
+let nextId = 1;
+let failed = false;
+
+createInterface({ input: child.stdout }).on("line", (line) => {
+  line = line.trim();
+  if (!line) return;
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    console.error(`<-- (non-JSON) ${line}`);
+    return;
+  }
+  if (msg.id !== undefined && (msg.result !== undefined || msg.error)) {
+    const waiter = pending.get(msg.id);
+    console.log(`<-- response #${msg.id} (${waiter?.method ?? "?"})`);
+    console.log(JSON.stringify(msg.result ?? msg.error, null, 2));
+    if (msg.error) failed = true;
+    waiter?.resolve(msg);
+    pending.delete(msg.id);
+  } else if (msg.method) {
+    // A notification or a server->client request. We only observe these.
+    notifications.push(msg);
+    const update = msg.params?.update;
+    let detail = "";
+    if (update?.sessionUpdate === "agent_message_chunk") {
+      // The streamed assistant text — one chunk per AgentMessageChunk. With the
+      // streaming backend a real prompt produces many of these.
+      detail = ` ${JSON.stringify(update.content?.text ?? update.content)}`;
+    } else if (update?.sessionUpdate) {
+      detail = ` (${update.sessionUpdate})`;
+    }
+    console.log(`<-- notify ${msg.method}${detail}`);
+  }
+});
+
+function send(method, params) {
+  const id = nextId++;
+  const req = { jsonrpc: "2.0", id, method, params };
+  console.log(`--> request #${id} ${method}`);
+  child.stdin.write(JSON.stringify(req) + "\n");
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, method });
+    setTimeout(() => {
+      if (pending.has(id)) {
+        pending.delete(id);
+        reject(new Error(`timeout waiting for ${method} (#${id})`));
+      }
+    }, 20_000);
+  });
+}
+
+async function main() {
+  // 1. Handshake.
+  await send("initialize", {
+    protocolVersion: 1,
+    clientCapabilities: {},
+  });
+
+  // 2. Open a session rooted at the repo. `cwd` must be absolute.
+  const sessionRes = await send("session/new", {
+    cwd: process.cwd(),
+    mcpServers: [],
+  });
+  const sessionId = sessionRes.result?.sessionId;
+  if (!sessionId) throw new Error("session/new returned no sessionId");
+
+  // 3. Drive a no-inference slash command through the prompt surface. `/whoami`
+  //    reports the signed-in account; it never touches the model.
+  await send("session/prompt", {
+    sessionId,
+    prompt: [{ type: "text", text: "/whoami" }],
+  });
+
+  console.log("\nOK — ACP handshake, session, and /whoami round-tripped.");
+}
+
+main()
+  .catch((err) => {
+    console.error(`FAILED: ${err.message}`);
+    failed = true;
+  })
+  .finally(() => {
+    child.kill("SIGTERM");
+    setTimeout(() => process.exit(failed ? 1 : 0), 150);
+  });

sigit_code-1.3.0/.claude/skills/run-sigit/tui-smoke.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Drive the interactive ratatui TUI under tmux: launch it, type /help, dump the
+# rendered screen to a file ("screenshot" for a terminal app), then quit cleanly.
+#
+# The TUI only starts when stdin is a real TTY, so it must run inside a terminal
+# multiplexer — tmux gives us one plus `capture-pane` to read what it drew.
+# Requires tmux (`brew install tmux`). Unix only (the TUI is #[cfg(unix)]).
+#
+# Usage: .claude/skills/run-sigit/tui-smoke.sh [path-to-binary]
+set -euo pipefail
+
+BIN="${1:-${SIGIT_BIN:-target/debug/sigit}}"
+SESSION="sigit-smoke-$$"
+OUT="${TMPDIR:-/tmp}/sigit-tui.txt"
+
+if [[ ! -x "$BIN" ]]; then
+  echo "binary not found/executable: $BIN — run \`cargo build\` first" >&2
+  exit 2
+fi
+command -v tmux >/dev/null || { echo "tmux not installed (brew install tmux)" >&2; exit 2; }
+
+cleanup() { tmux kill-session -t "$SESSION" 2>/dev/null || true; }
+trap cleanup EXIT
+
+tmux new-session -d -s "$SESSION" -x 120 -y 35
+tmux send-keys -t "$SESSION" "$BIN" Enter
+sleep 6                                   # banner + (lazy) model selection
+tmux send-keys -t "$SESSION" '/help' Enter
+sleep 2
+tmux capture-pane -t "$SESSION" -p > "$OUT"
+tmux send-keys -t "$SESSION" C-c          # Ctrl+C quits
+sleep 1
+
+echo "Captured TUI screen -> $OUT"
+if grep -q '/whoami' "$OUT"; then
+  echo "OK — TUI launched and /help rendered."
+else
+  echo "FAILED — /help output not found in capture:" >&2
+  sed '/^$/d' "$OUT" | head -40 >&2
+  exit 1
+fi

{sigit_code-1.2.1 → sigit_code-1.3.0}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 1.3.0
+
+Adds a Local Inference on/off toggle, the open [Agent Skills](https://agentskills.io)
+format, and support for project instruction files (`AGENTS.md` and the like).
+
+### What changed
+
+- Added a Local Inference on/off setting that is the explicit local-vs-cloud mode switch. It is persisted in `~/.config/sigit/settings.toml` (default on, local-first) and can be overridden with `SIGIT_LOCAL_INFERENCE`
+- Toggle it with the `/local [on|off]` command (TUI and ACP); ACP clients without slash-command support get an equivalent "Local Inference" On/Off control in the session config panel
+- `/models` now groups models by nature — Local vs siGit Code Cloud — and highlights the active mode's group while still showing the other, so the cloud tiers stay discoverable
+- Discovers Agent Skills (folders with a `SKILL.md`) from `.sigit/skills/` and `.claude/skills/` in the project, `~/.config/sigit/skills/`, and `~/.claude/skills/`
+- Follows the spec's progressive disclosure: each skill's name and description are advertised up front via a new `skill` tool, and the full instructions load only when the agent activates one
+- Added a `/skills` slash command (TUI and ACP) that lists the discovered skills
+- Reads project instruction files at session start: `AGENTS.md` (the cross-tool standard) and `CLAUDE.md`, walking from the working directory up to the repository root, plus a global file under `~/.config/sigit/`, and injects them into the session's system context so their guidance is always in force
+- Nested instruction files are ordered outermost-first so the closest, most specific file takes precedence; the scan never reads above the repository root
+- On-device models are no longer loaded implicitly. The chat UI and ACP sessions come up immediately, and the local model is brought into memory only when you run the `/load` command (or pick one in `/models`). Prompts sent before a model is loaded now return a hint instead of blocking on a multi-minute download.
+
+## 1.2.2
+
+Streams assistant tokens as they arrive, on-device and over the cloud.
+
+### What changed
+
+- Streamed assistant tokens live in the TUI and ACP sessions, both on-device and through siGit Code Cloud
+- On-device inference streams only when a turn offers no tools, since `onde` can't stream and detect tool calls in the same pass; tool-capable turns still resolve in one shot
+- Fixed the TUI so the latest message stays visible in long chats
+- Put the cloud model-switch confirmation on its own line in ACP
+
 ## 1.2.1
 
 Stabilizes the Zed/ACP integration and finishes the cloud-tier wiring on top of 1.2.0.

{sigit_code-1.2.1 → sigit_code-1.3.0}/CLAUDE.md

@@ -64,6 +64,21 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
 - **`src/tools.rs`** — agent tool schemas + execution: `read_file`, `create_directory`,
   `list_directory`, `search_files`, `read_website`, `create_file`, `edit_file`, `delete_file`,
   `run_command`. Add a tool in both the spec list and the execute `match`.
+- **`src/skills.rs`** — [Agent Skills](https://agentskills.io) support. Discovers skill
+  folders (each with a `SKILL.md`: YAML frontmatter `name` + `description`, then Markdown
+  instructions) from `.sigit/skills/` and `.claude/skills/` in the cwd, `$SIGIT_CONFIG_DIR/skills/`,
+  and `~/.claude/skills/`. Progressive disclosure: the discovery list (name + description) is
+  baked into the dynamically-built `skill` tool's description, and activating a skill (the model
+  calls `skill` with a name) loads the full `SKILL.md` body. The `skill` tool is appended in the
+  `*_as_specs`/`build_tool_specs` layer (not in `all_tools()`) so its description can be dynamic,
+  and only when at least one skill exists.
+- **`src/instructions.rs`** — project instruction files, the always-on counterpart to skills.
+  Reads `AGENTS.md` (the cross-tool [agents.md](https://agents.md) standard) and `CLAUDE.md`,
+  walking from the session cwd up to the repo root (nearest ancestor with `.git`, never above it),
+  plus a global file under `$SIGIT_CONFIG_DIR`. Files are ordered outermost-first so the deepest
+  (most specific) wins. The combined block is injected via `session_context_message` in `main.rs`
+  — pushed as a system message at every ACP session entry point (new/load/fork + model switch)
+  and appended to the system prompt on the cloud and TUI-startup paths.
 - **`src/chat.rs`** — the Unix-only ratatui TUI. Loading-spinner phase then chat; uses
   `tokio::select!` to multiplex terminal events with streaming tokens.
 - **`src/setup.rs`** — model cache location, local model discovery, selected-model persistence.
@@ -74,9 +89,9 @@ feeds results back. Neither the loop nor ACP/TUI surfaces depend on a concrete b
 - **`src/credentials.rs`** — local session-token store (TOML, `0600` on Unix).
 - **`src/models.rs`** — model-picker types shared across platforms.
 
-Slash commands (`/help`, `/models`, `/login`, `/logout`, `/whoami`, `/reload`, `/clear`,
-`/status`) are advertised via `advertise_commands` in `main.rs` and handled in both the TUI and
-ACP sessions.
+Slash commands (`/help`, `/models`, `/skills`, `/login`, `/logout`, `/whoami`, `/reload`,
+`/clear`, `/status`) are advertised via `advertise_commands` in `main.rs` and handled in both the
+TUI and ACP sessions.
 
 ## Model cache (macOS)
 

{sigit_code-1.2.1 → sigit_code-1.3.0}/Cargo.lock

@@ -20,9 +20,9 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "agent-client-protocol"
-version = "0.13.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e037424fa2da7aea1363b42e0c792d117b4d0ceb9d6d6f58719ce7520c22eabf"
+checksum = "16302d16c7531355db16593d99c38c8297db0c4653aa7dd80c3556bb17f4cd8c"
 dependencies = [
  "agent-client-protocol-derive",
  "agent-client-protocol-schema",
@@ -30,7 +30,6 @@ dependencies = [
  "blocking",
  "futures",
  "futures-concurrency",
- "jsonrpcmsg",
  "rustc-hash 2.1.2",
  "schemars 1.2.1",
  "serde",
@@ -38,13 +37,14 @@ dependencies = [
  "shell-words",
  "tracing",
  "uuid 1.23.3",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "agent-client-protocol-derive"
-version = "0.11.1"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cabdc9d845d08ec7ed2d0c9de1ae4a1b198301407d55855261572761be90ec9f"
+checksum = "88b37d552feb6981a0109febda6b71fc723678cd065974c2d76279c19c407095"
 dependencies = [
  "quote",
  "syn 2.0.117",
@@ -52,9 +52,9 @@ dependencies = [
 
 [[package]]
 name = "agent-client-protocol-schema"
-version = "0.13.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dd79d476e25d8562d46b368eb5fc629edd3dd6be75e6b036606e6f4f867e7e7"
+checksum = "ac542aba230234b1591ace7286a47c0514fe3efc3037d43296bde31ba7ee5728"
 dependencies = [
  "anyhow",
  "derive_more",
@@ -2879,16 +2879,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "jsonrpcmsg"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d833a15225c779251e13929203518c2ff26e2fe0f322d584b213f4f4dad37bd"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -5210,7 +5200,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.2.1"
+version = "1.3.0"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.2.1 → sigit_code-1.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sigit"
-version = "1.2.1"
+version = "1.3.0"
 edition = "2024"
 description = "siGit Code — ACP-compatible AI coding agent. Sí, git."
 documentation = "https://github.com/getsigit/sigit"
@@ -18,7 +18,7 @@ path = "src/main.rs"
 
 [dependencies]
 # ACP protocol SDK
-agent-client-protocol = { version = "0.13", features = ["unstable_session_fork", "unstable_session_additional_directories", "unstable_auth_methods"] }
+agent-client-protocol = { version = "1.0", features = ["unstable_session_fork", "unstable_auth_methods"] }
 
 # Onde Inference engine (local LLM)
 # onde = { path = "../onde" }
@@ -30,7 +30,10 @@ tokio-util = { version = "0.7", features = ["compat"] }
 futures = "0.3"
 
 # TUI (interactive chat mode)
-ratatui = "0.29"
+# `unstable-rendered-line-info` exposes `Paragraph::line_count`, which we use to
+# pin the message view to the bottom using the exact wrapped-row count (the same
+# WordWrapper that rendering uses) rather than a hand-rolled estimate.
+ratatui = { version = "0.29", features = ["unstable-rendered-line-info"] }
 crossterm = { version = "0.29", features = ["event-stream"] }
 
 # Utilities
@@ -43,6 +46,6 @@ serde_json = "1"
 toml = "0.8"
 async-trait = "0.1"
 regex = "1"
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls", "stream"] }
 uuid = { version = "1", features = ["v4"] }
 rpassword = "7"

{sigit_code-1.2.1 → sigit_code-1.3.0}/PKG-INFO

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

{sigit_code-1.2.1 → sigit_code-1.3.0}/README.md

@@ -10,6 +10,8 @@
 
 siGit Code is a local coding agent. It runs on your machine, not someone else's. No API keys, no cloud round-trips, no subscription.
 
+Its home is [code.sigit.si](https://code.sigit.si). You can run it yourself, as below, or use the hosted version (siGit Code Cloud) there if you would rather not run a model locally. [sigit.si](https://sigit.si) is Git hosting built for AI workflows.
+
 It works in any codebase. In smbCloud repos it is more useful out of the box because it already understands the Rust workspace layout, deploy flows, auth boundaries, and GresIQ.
 
 You can use it in two ways:
@@ -23,17 +25,6 @@ You can use it in two ways:
 | Linux | ✓ | ✓ |
 | Windows | ✓ | not yet |
 
-## smbCloud context
-
-In an smbCloud repo, siGit Code already knows a few important things:
-
-- platform-user flows and tenant-app auth flows are different systems
-- `Project` is the umbrella workspace, while `FrontendApp`, `AuthApp`, and GresIQ are separate deployable units
-- Next.js SSR deploys are not the same thing as the generic git-push path
-- existing crate boundaries and workspace patterns are usually the right place to start
-
-In other repos it stays general and does not pretend everything is about smbCloud.
-
 ## Install
 
 ```sh
@@ -70,7 +61,27 @@ Add this to `~/.config/zed/settings.json`:
 
 Use the full absolute path. `~` does not expand here.
 
-## VS Code with ACP Client
+## VS Code
+
+### With siGit Code Extension
+
+Install from the [Visual Studio Code Marketplace](https://marketplace.visualstudio.com/items?itemName=getsigit.sigit-code).
+
+```jsonc
+{
+  "sigit.agents": {
+    "sigit": {
+      "name": "siGit (on-device)",
+      "command": "sigit",
+      "args": [],
+      "env": {}
+    },
+  },
+  "sigit.agent.default": "sigit"
+}
+```
+
+### With ACP Client
 
 Install [ACP Client](https://marketplace.visualstudio.com/items?itemName=formulahendry.acp-client), then add:
 
@@ -106,4 +117,4 @@ Terminal mode currently needs Unix terminal behavior, so it works on macOS and L
 
 ## Copyright
 
-© 2026 [smbCloud](https://smbcloud.xyz/) (Splitfire AB).
+© 2026 [smbCloud Platform](https://smbcloud.xyz/) (Splitfire AB).

sigit_code-1.3.0/examples/skills/README.md

@@ -0,0 +1,36 @@
+# Example Agent Skills
+
+siGit Code supports the open [Agent Skills](https://agentskills.io) format. A
+skill is a folder containing a `SKILL.md` file — YAML frontmatter (`name` and
+`description`, at minimum) followed by Markdown instructions. Skills can bundle
+`scripts/`, `references/`, and `assets/` that the agent reads on demand.
+
+## Installing a skill
+
+Copy a skill folder into one of the directories siGit scans (in priority order):
+
+- `.sigit/skills/` or `.claude/skills/` in your project (project-local)
+- `~/.config/sigit/skills/` (honours `$SIGIT_CONFIG_DIR`)
+- `~/.claude/skills/` (shared with the broader ecosystem)
+
+For example, to install the `commit-message` skill here for the current project:
+
+```sh
+mkdir -p .sigit/skills
+cp -R examples/skills/commit-message .sigit/skills/
+```
+
+The folder name must match the skill's `name` field.
+
+## How siGit uses them
+
+siGit follows the spec's *progressive disclosure*:
+
+1. **Discovery** — at the start of each turn, siGit loads only each skill's
+   `name` and `description` into the `skill` tool's description.
+2. **Activation** — when your task matches a skill, the agent calls the `skill`
+   tool with that name, which loads the full `SKILL.md` into context.
+3. **Execution** — the agent follows the instructions, reading any bundled files
+   from the skill's directory with its normal file and command tools.
+
+Run `/skills` to list the skills siGit can see.

sigit_code-1.3.0/examples/skills/commit-message/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: commit-message
+description: Write a clear git commit message from staged changes. Use when the user asks to commit, write a commit message, or describe staged changes.
+license: Apache-2.0
+metadata:
+  author: sigit
+  version: "1.0"
+---
+
+# Commit message
+
+Write a concise, conventional commit message that describes *why* a change was
+made, not just what changed.
+
+## Steps
+
+1. Inspect what is staged: run `git diff --cached` (and `git status` for context).
+2. Group the changes into a single logical intent. If they span unrelated
+   concerns, say so and suggest splitting the commit.
+3. Write the message:
+   - **Subject line**: imperative mood, lowercase after the type, no trailing
+     period, ≤ 50 characters. Prefix with a type when it fits the repo's
+     convention (`feat:`, `fix:`, `refactor:`, `docs:`, `test:`, `chore:`).
+   - **Body** (optional): wrap at 72 columns. Explain the motivation and any
+     non-obvious tradeoffs. Reference issues if relevant.
+4. Show the message to the user before committing. Only run `git commit` if they
+   confirm.
+
+## Examples
+
+Good subject lines:
+
+```
+fix: stop the picker from reloading a working model on /reload
+refactor: extract skill discovery into its own module
+```
+
+Avoid:
+
+```
+Update files
+fixed bug
+WIP
+```