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,218 @@
+use agent_client_protocol as acp;
+use kigi_sampling_types::{ReasoningEffort, ReasoningEffortOption};
+use serde::Serialize;
+
+use crate::session::unified_list::SessionKind;
+
+pub(crate) const SELECTABLE_REASONING_EFFORTS: [ReasoningEffort; 5] = [
+    ReasoningEffort::Minimal,
+    ReasoningEffort::Low,
+    ReasoningEffort::Medium,
+    ReasoningEffort::High,
+    ReasoningEffort::Xhigh,
+];
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionConfigOption {
+    pub id: String,
+    pub category: String,
+    pub label: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub selected: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GrokSessionDetail {
+    pub session_id: String,
+    pub kind: String,
+    pub cwd: String,
+    pub current_model_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+}
+
+impl GrokSessionDetail {
+    pub fn build(
+        session_id: String,
+        cwd: String,
+        current_model_id: String,
+        title: Option<String>,
+    ) -> Self {
+        Self {
+            session_id,
+            kind: SessionKind::Build.as_str().to_string(),
+            cwd,
+            current_model_id,
+            title,
+        }
+    }
+}
+
+fn effort_label(effort: ReasoningEffort) -> String {
+    match effort {
+        ReasoningEffort::None => "None",
+        ReasoningEffort::Minimal => "Minimal",
+        ReasoningEffort::Low => "Low",
+        ReasoningEffort::Medium => "Medium",
+        ReasoningEffort::High => "High",
+        ReasoningEffort::Xhigh => "X-High",
+    }
+    .to_string()
+}
+
+/// The built-in session-picker modes used when the model has no server list.
+/// Reproduces the historical five rows and their labels.
+pub(crate) fn legacy_session_effort_options() -> Vec<ReasoningEffortOption> {
+    SELECTABLE_REASONING_EFFORTS
+        .iter()
+        .map(|&effort| ReasoningEffortOption {
+            id: effort.as_str().to_string(),
+            value: effort,
+            label: effort_label(effort),
+            description: None,
+            default: false,
+        })
+        .collect()
+}
+
+pub(crate) fn build_session_config_options(
+    available_models: &[acp::ModelInfo],
+    current_model_id: &acp::ModelId,
+    effort_options: &[ReasoningEffortOption],
+    current_effort: Option<ReasoningEffort>,
+) -> Vec<SessionConfigOption> {
+    let mut options = Vec::with_capacity(available_models.len() + effort_options.len());
+
+    for model in available_models {
+        let label = if model.name.is_empty() {
+            model.model_id.0.to_string()
+        } else {
+            model.name.clone()
+        };
+        options.push(SessionConfigOption {
+            id: model.model_id.0.to_string(),
+            category: "model".to_string(),
+            label,
+            description: None,
+            selected: model.model_id == *current_model_id,
+        });
+    }
+
+    for effort in effort_options {
+        options.push(SessionConfigOption {
+            id: effort.id.clone(),
+            category: "mode".to_string(),
+            label: effort.label.clone(),
+            description: effort.description.clone(),
+            selected: Some(effort.value) == current_effort,
+        });
+    }
+
+    options
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn model(id: &'static str, name: &str) -> acp::ModelInfo {
+        acp::ModelInfo::new(acp::ModelId::new(id), name.to_string())
+    }
+
+    #[test]
+    fn options_have_one_selected_model_and_a_mode_per_effort() {
+        let models = [
+            model("grok-build", "Grok Build"),
+            model("grok-4.5", "Grok 4.5"),
+        ];
+        let current = acp::ModelId::from("grok-build");
+        let opts = build_session_config_options(
+            &models,
+            &current,
+            &legacy_session_effort_options(),
+            Some(ReasoningEffort::High),
+        );
+
+        let model_opts: Vec<_> = opts.iter().filter(|o| o.category == "model").collect();
+        assert_eq!(model_opts.len(), 2);
+        let selected_models: Vec<_> = model_opts.iter().filter(|o| o.selected).collect();
+        assert_eq!(selected_models.len(), 1);
+        assert_eq!(selected_models[0].id, "grok-build");
+
+        let mode_opts: Vec<_> = opts.iter().filter(|o| o.category == "mode").collect();
+        assert_eq!(mode_opts.len(), SELECTABLE_REASONING_EFFORTS.len());
+        let selected_modes: Vec<_> = mode_opts.iter().filter(|o| o.selected).collect();
+        assert_eq!(selected_modes.len(), 1);
+        assert_eq!(selected_modes[0].id, "high");
+        assert_eq!(selected_modes[0].label, "High");
+    }
+
+    #[test]
+    fn none_effort_is_not_a_user_selectable_mode() {
+        assert!(!SELECTABLE_REASONING_EFFORTS.contains(&ReasoningEffort::None));
+        let models = [model("grok-build", "Grok Build")];
+        let current = acp::ModelId::from("grok-build");
+        let opts = build_session_config_options(
+            &models,
+            &current,
+            &legacy_session_effort_options(),
+            Some(ReasoningEffort::None),
+        );
+        let modes: Vec<_> = opts.iter().filter(|o| o.category == "mode").collect();
+        assert!(modes.iter().all(|o| o.id != "none"));
+        assert!(modes.iter().all(|o| !o.selected));
+    }
+
+    #[test]
+    fn no_mode_options_when_model_lacks_effort_support() {
+        let models = [model("grok-build", "Grok Build")];
+        let current = acp::ModelId::from("grok-build");
+        let opts = build_session_config_options(&models, &current, &[], None);
+        assert_eq!(opts.len(), 1);
+        assert!(opts.iter().all(|o| o.category == "model"));
+    }
+
+    #[test]
+    fn model_label_falls_back_to_id_when_name_empty() {
+        let models = [model("grok-build", "")];
+        let current = acp::ModelId::from("grok-build");
+        let opts = build_session_config_options(&models, &current, &[], None);
+        assert_eq!(opts[0].label, "grok-build");
+    }
+
+    #[test]
+    fn session_config_option_serializes_camel_case() {
+        let opt = SessionConfigOption {
+            id: "grok-build".to_string(),
+            category: "model".to_string(),
+            label: "Grok Build".to_string(),
+            description: None,
+            selected: true,
+        };
+        let v = serde_json::to_value(&opt).expect("serialize");
+        assert_eq!(v["id"], "grok-build");
+        assert_eq!(v["category"], "model");
+        assert_eq!(v["label"], "Grok Build");
+        assert_eq!(v["selected"], true);
+        assert!(v.get("description").is_none());
+    }
+
+    #[test]
+    fn grok_session_detail_serializes_camel_case() {
+        let detail = GrokSessionDetail::build(
+            "sess-1".to_string(),
+            "/Users/me/xai".to_string(),
+            "grok-build".to_string(),
+            None,
+        );
+        let v = serde_json::to_value(&detail).expect("serialize");
+        assert_eq!(v["sessionId"], "sess-1");
+        assert_eq!(v["kind"], "build");
+        assert_eq!(v["cwd"], "/Users/me/xai");
+        assert_eq!(v["currentModelId"], "grok-build");
+        assert!(v.get("title").is_none());
+    }
+}