M0: compilable skeleton — Kigi 0.1.0 fork surgery

Hard fork of xai-org/grok-build (Apache-2.0) re-targeted as Kigi, an unofficial Kimi Code CLI community build. Rename & identity - 72 xai-*/xai-grok-* crates -> kigi-* (explicit: xai-grok-pager-bin -> kigi-bin [binary `kigi`], xai-grok-pager -> kigi-tui; rest mechanical); ptyctl, ptyctl-cli, third_party/ unchanged; proto package xai.grok.tools.v1 -> kigi.tools.v1 - Config home ~/.kigi (KIGI_SHARE_DIR override), env prefix GROK_* -> KIGI_*, `kigi --version` carries the unofficial-community-build notice - clap identity, help text, startup banner, prompt templates rebranded (templates re-encrypted) Deletions (PRD removal list #5/#6/#7/#9/#10) - voice input (xai-grok-voice) and all TUI wiring - telemetry: Mixpanel client, external OTel stream, Sentry, OTLP layers, trace/GCS/S3 upload queues (kigi-file-utils halved), workspace upload module & dc_log, heap-profile uploader, auth-diagnostics uploader, session-analytics halves of feedback; local zero-egress observability preserved in new kigi-log crate (unified log, --debug firehose, subsystem file logs, opt-in instrumentation) - announcements (crate, remote-settings fields, TUI surfaces) - plugin marketplace (crate, sources/browse/CTA/extensions-modal tab); direct plugin install/uninstall/update via kigi-agent git_install kept - relay/gateway/assets endpoints and features (agent relay, headless relay transport, gateway bridge, LeaderEnvUrls); leader IPC socket now ~/.kigi/leader.sock + KIGI_LEADER_SOCKET, no ws-url derivation - functional types rehomed instead of deleted: PermissionMode -> kigi-config-types, McpInitStrategy -> kigi-mcp, PrCreationSource -> session signals, TerminalDiagnostics -> kigi-pager-render, agent_id -> shell util Endpoints - kigi-env rewritten: single production KigiEndpoints {coding_api_base_url https://api.kimi.com/coding/v1 (KIGI_CODE_BASE_URL), oauth_host https://auth.kimi.com (KIGI_OAUTH_HOST), update_base_url (GitHub Releases API), upgrade_page_url}; GrokBuildEnvironment enum deleted Toolchain & workspace hygiene - Rust 1.97.0 pinned; edition 2024; full cargo update; git2 hoisted to workspace at 0.21 (Option->Result API migration), quick-xml 0.41 - Root Cargo.toml hand-maintained (PRD §8.1): version 0.1.0 inherited by all members, members sorted, unused deps pruned - cargo-deny advisories gate (deny.toml with documented transitive exceptions); CI workflow (check/clippy/fmt/deny/test, macOS+Linux) - cross-crate test seams re-gated behind `test-support` cargo feature; insta snapshot baselines renamed to the kigi_tui prefix - clippy --workspace --all-targets: zero warnings; fmt clean Fixes surfaced by the port - updater probe/installer divergence (bin/kigi vs bin/grok symlink set) - idle model-metadata refresh dead under KIGI_CODE_BASE_URL override (new is_effective_coding_endpoint_url, loopback+override aware) - macOS symlinked-TMPDIR fixture canonicalization (foreign_sessions, fast-worktree); RSS measurement tests serialized via serial_test Docs & legal (Apache §4) - NOTICE added (upstream attribution + change statement); THIRD-PARTY notices sustained; kigi-tools ported-code notices extended; README, CONTRIBUTING, SECURITY, AGENTS.md rewritten Out of scope for M0 (tracked): Kimi auth/inference (M1), search/fetch, command parity, config import (M2), Computer Hub excision & final brand-token sweep (M2), distribution & self-update rewrite (M3).
2026-07-17 05:31:01 -04:00
commit d6c20fc13f
2612 changed files with 1353757 additions and 0 deletions
@@ -0,0 +1,177 @@
+//! Streaming `Tool::execute` overrides — interleaving Progress with a
+//! single Terminal item.
+
+use std::pin::Pin;
+
+use futures::stream::{self, Stream, StreamExt};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use kigi_tool_protocol::{StreamingSpec, ToolCapabilities, ToolId};
+use kigi_tool_runtime::{
+    ContentBlock, Tool, ToolCallContext, ToolError, ToolErrorKind, ToolOutput, ToolProgress,
+    ToolStream, ToolStreamItem, with_progress,
+};
+use kigi_tool_types::ToolDescription;
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+struct EmptyArgs {}
+
+#[derive(Debug, Serialize, PartialEq)]
+struct UnitOutput {
+    pub value: u32,
+}
+
+impl ToolOutput for UnitOutput {}
+struct StreamingOk;
+
+impl Tool for StreamingOk {
+    type Args = EmptyArgs;
+    type Output = UnitOutput;
+
+    fn id(&self) -> ToolId {
+        ToolId::new("streaming_ok").unwrap()
+    }
+
+    fn description(&self, _ctx: &::kigi_tool_runtime::ListToolsContext) -> ToolDescription {
+        ToolDescription::new("streaming_ok", "ok")
+    }
+
+    fn capabilities(&self) -> ToolCapabilities {
+        ToolCapabilities {
+            streaming: Some(StreamingSpec {
+                subkind: "streaming_ok_chunk".to_owned(),
+                max_delta_bytes: None,
+            }),
+            ..Default::default()
+        }
+    }
+
+    async fn execute(&self, _ctx: ToolCallContext, _args: Self::Args) -> ToolStream<UnitOutput> {
+        let progress: Pin<Box<dyn Stream<Item = ToolProgress> + Send>> =
+            Box::pin(stream::iter(vec![
+                ToolProgress::Text {
+                    text: "first".into(),
+                },
+                ToolProgress::Text {
+                    text: "second".into(),
+                },
+                ToolProgress::Content {
+                    blocks: vec![ContentBlock::Text {
+                        text: "third block".into(),
+                    }],
+                },
+            ]));
+        with_progress(progress, async move { Ok(UnitOutput { value: 7 }) })
+    }
+}
+
+struct StreamingErr;
+
+impl Tool for StreamingErr {
+    type Args = EmptyArgs;
+    type Output = UnitOutput;
+
+    fn id(&self) -> ToolId {
+        ToolId::new("streaming_err").unwrap()
+    }
+
+    fn description(&self, _ctx: &::kigi_tool_runtime::ListToolsContext) -> ToolDescription {
+        ToolDescription::new("streaming_err", "err")
+    }
+
+    async fn execute(&self, _ctx: ToolCallContext, _args: Self::Args) -> ToolStream<UnitOutput> {
+        let progress = stream::iter(vec![ToolProgress::Text {
+            text: "before terminal".into(),
+        }]);
+        with_progress(progress, async move {
+            Err(ToolError::custom("intentional_failure", "boom"))
+        })
+    }
+}
+
+#[tokio::test]
+async fn streaming_ok_emits_progress_then_terminal() {
+    let tool = StreamingOk;
+    let ctx = ToolCallContext::default();
+    let mut items: Vec<_> = tool.execute(ctx, EmptyArgs {}).await.collect().await;
+    assert_eq!(items.len(), 4, "expected 3 progress + 1 terminal");
+
+    let terminal = items.pop().unwrap();
+    assert!(terminal.is_terminal(), "last item must be Terminal");
+    let earlier_terminals = items.iter().filter(|i| i.is_terminal()).count();
+    assert_eq!(earlier_terminals, 0, "Terminal must only appear last");
+
+    match terminal {
+        ToolStreamItem::Terminal(Ok(out)) => assert_eq!(out, UnitOutput { value: 7 }),
+        other => panic!("expected Terminal(Ok), got {other:?}"),
+    }
+
+    let progress_kinds: Vec<_> = items
+        .into_iter()
+        .map(|item| match item {
+            ToolStreamItem::Progress(p) => p,
+            ToolStreamItem::Terminal(_) => unreachable!(),
+        })
+        .collect();
+    assert_eq!(progress_kinds.len(), 3);
+    assert!(matches!(progress_kinds[0], ToolProgress::Text { .. }));
+    assert!(matches!(progress_kinds[2], ToolProgress::Content { .. }));
+}
+
+#[tokio::test]
+async fn streaming_err_propagates_through_terminal() {
+    let tool = StreamingErr;
+    let ctx = ToolCallContext::default();
+    let items: Vec<_> = tool.execute(ctx, EmptyArgs {}).await.collect().await;
+    assert_eq!(items.len(), 2);
+
+    match &items[0] {
+        ToolStreamItem::Progress(ToolProgress::Text { text }) => {
+            assert_eq!(text, "before terminal");
+        }
+        other => panic!("expected Progress(Text), got {other:?}"),
+    }
+
+    match &items[1] {
+        ToolStreamItem::Terminal(Err(err)) if err.kind == ToolErrorKind::Custom => {
+            let code = err
+                .details
+                .as_ref()
+                .and_then(|d| d.get("code"))
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            assert_eq!(code, "intentional_failure");
+            assert_eq!(err.detail, "boom");
+        }
+        other => panic!("expected Terminal(Err(Custom)), got {other:?}"),
+    }
+}
+
+#[tokio::test]
+async fn streaming_progress_count_is_independent_of_args() {
+    // Distinct invocations on the same tool produce the same shape.
+    let tool = StreamingOk;
+    for _ in 0..3 {
+        let count = tool
+            .execute(ToolCallContext::default(), EmptyArgs {})
+            .await
+            .count()
+            .await;
+        assert_eq!(count, 4);
+    }
+}
+
+#[tokio::test]
+async fn empty_progress_still_yields_terminal() {
+    // Building `with_progress` on an empty stream still produces exactly
+    // one terminal item — the same shape `terminal_only` produces.
+    let progress = stream::iter(Vec::<ToolProgress>::new());
+    let mut stream = with_progress(progress, async move { Ok::<u32, ToolError>(99) });
+    let item = stream.next().await.unwrap();
+    match item {
+        ToolStreamItem::Terminal(Ok(v)) => assert_eq!(v, 99),
+        other => panic!("expected Terminal(Ok(99)), got {other:?}"),
+    }
+    assert!(stream.next().await.is_none());
+}