ZacharyZhang-NY/Kigi-CLI
1
0
Fork 0
Code Issues Pull Requests Actions 13 Packages Projects Releases Wiki Activity

M0: compilable skeleton — Kigi 0.1.0 fork surgery

Browse Source 
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).
This commit is contained in:
ZacharyZhang-NY
2026-07-17 05:31:01 -04:00
commit d6c20fc13f
2612 changed files with 1353757 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/ordered_hashmap/src/lib.rs
Vendored
+333
View File
@@ -0,0 +1,333 @@
use std::collections::hash_map::Entry as StdEntry;
use std::collections::HashMap;
use std::hash::Hash;
/// A custom `OrderedHashMap` struct that maintains the order of keys.
/// It wraps a `Vec` to store keys and a `HashMap` to store key-value pairs.
#[derive(Clone, Debug, PartialEq)]
pub struct OrderedHashMap<K: Eq + Hash + Clone, V> {
pub keys: Vec<K>,
pub map: HashMap<K, V>,
}
impl<K: Eq + Hash + Clone, V> OrderedHashMap<K, V> {
/// Creates a new empty `OrderedHashMap`.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let ordered_map: OrderedHashMap<String, i32> = OrderedHashMap::new();
/// ```
pub fn new() -> Self {
OrderedHashMap {
keys: Vec::new(),
map: HashMap::new(),
}
}
/// Returns `true` if the map contains a value for the specified key.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// assert!(ordered_map.contains_key(&"key1".to_string()));
/// ```
pub fn contains_key(&self, k: &K) -> bool {
self.map.contains_key(k)
}
/// Inserts a key-value pair into the map. If the map did not have this key present, `None` is returned.
/// If the map did have this key present, the value is updated, and the old value is returned.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// assert_eq!(ordered_map.insert("key1".to_string(), 42), None);
/// assert_eq!(ordered_map.insert("key1".to_string(), 99), Some(42));
/// ```
pub fn insert(&mut self, key: K, value: V) -> Option<V> {
if !self.map.contains_key(&key) {
self.keys.push(key.clone());
}
self.map.insert(key, value)
}
/// Removes a key from the map, returning the value at the key if the key was previously in the map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// assert_eq!(ordered_map.remove(&"key1".to_string()), Some(42));
/// ```
pub fn remove(&mut self, key: &K) -> Option<V> {
self.keys.retain(|k| k != key);
self.map.remove(key)
}
/// Gets the value of the specified key.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// assert_eq!(ordered_map.get(&"key1".to_string()), Some(&42));
/// ```
pub fn get(&self, key: &K) -> Option<&V> {
self.map.get(key)
}
/// Gets a mutable reference to the value of the specified key.
//////
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// *ordered_map.get_mut(&"key1".to_string()).unwrap() += 1;
/// assert_eq!(ordered_map.get(&"key1".to_string()), Some(&43));
/// ```
pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
self.map.get_mut(key)
}
/// Returns an iterator over the values in the ordered hash map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.insert("key2".to_string(), 24);
/// let values: Vec<_> = ordered_map.values().collect();
/// assert_eq!(values, vec![&42, &24]);
/// ```
pub fn values(&self) -> impl Iterator<Item = &V> {
self.keys.iter().filter_map(|k| self.map.get(k))
}
/// Returns a mutable iterator over the values in the ordered hash map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.insert("key2".to_string(), 24);
/// ordered_map.values_mut().for_each(|value| *value += 1);
/// assert_eq!(ordered_map.get(&"key1".to_string()), Some(&43));
/// assert_eq!(ordered_map.get(&"key2".to_string()), Some(&25));
/// ```
pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
let map_ptr = &mut self.map as *mut HashMap<K, V>;
self.keys
.iter()
.filter_map(move |k| unsafe { (*map_ptr).get_mut(k) })
}
/// Returns an iterator over the keys in the ordered hash map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.insert("key2".to_string(), 24);
/// let keys: Vec<_> = ordered_map.keys().collect();
/// assert_eq!(keys, vec![&"key1".to_string(), &"key2".to_string()]);
/// ```
pub fn keys(&self) -> impl Iterator<Item = &K> {
self.keys.iter()
}
/// Returns an iterator over the key-value pairs in the ordered hash map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.insert("key2".to_string(), 24);
/// let pairs: Vec<_> = ordered_map.iter().collect();
/// assert_eq!(pairs, vec![(&"key1".to_string(), &42), (&"key2".to_string(), &24)]);
/// ```
pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
self.keys
.iter()
.filter_map(move |k| self.map.get(k).map(|v| (k, v)))
}
/// Returns an `Entry` for the given key, allowing for more complex manipulation of the stored values.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.entry("key1".to_string()).or_insert(99);
/// assert_eq!(ordered_map.get(&"key1".to_string()), Some(&42));
/// ```
pub fn entry(&mut self, key: K) -> Entry<K, V> {
match self.map.entry(key.clone()) {
StdEntry::Occupied(occupied) => Entry::Occupied(occupied),
StdEntry::Vacant(vacant) => {
self.keys.push(key.clone());
Entry::Vacant(vacant)
}
}
}
/// Returns a mutable iterator over the key-value pairs in the ordered hash map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
/// let mut ordered_map = OrderedHashMap::new();
/// ordered_map.insert("key1".to_string(), 42);
/// ordered_map.insert("key2".to_string(), 24);
/// ordered_map.iter_mut().for_each(|(key, value)| *value += 1);
/// assert_eq!(ordered_map.get(&"key1".to_string()), Some(&43));
/// assert_eq!(ordered_map.get(&"key2".to_string()), Some(&25));
/// ```
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> {
let map_ptr = &mut self.map as *mut HashMap<K, V>;
self.keys
.iter()
.filter_map(move |k| unsafe { (*map_ptr).get_mut(k).map(|v| (k, v)) })
}
/// Returns a vector of the values in the map, in the order corresponding to their keys.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
///
/// let mut map = OrderedHashMap::new();
/// map.insert(1, "one");
/// map.insert(2, "two");
/// map.insert(3, "three");
///
/// let values = map.into_values();
/// assert_eq!(values, vec!["one", "two", "three"]);
/// ```
pub fn into_values(self) -> Vec<V> {
let mut extracted_items: Vec<(K, V)> = self.map.into_iter().collect();
self.keys
.into_iter()
.filter_map(move |k| {
if let Some(index) = extracted_items.iter().position(|(key, _)| *key == k) {
Some(extracted_items.remove(index).1)
} else {
None
}
})
.collect::<Vec<_>>()
}
/// Adds all key-value pairs from another `OrderedHashMap` to this one, without replacing any existing pairs.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
///
/// let mut map1 = OrderedHashMap::new();
/// map1.insert(1, "one");
///
/// let mut map2 = OrderedHashMap::new();
/// map2.insert(2, "two");
///
/// map1.extend(map2);
///
/// assert_eq!(map1.get(&1), Some(&"one"));
/// assert_eq!(map1.get(&2), Some(&"two"));
/// ```
pub fn extend(&mut self, slice: OrderedHashMap<K, V>) {
slice.keys.into_iter().for_each(|k| {
if !self.keys.contains(&k) {
self.keys.push(k);
}
});
self.map.extend(slice.map);
}
/// Returns the number of key-value pairs in the map.
///
/// # Examples
///
/// ```
/// use ordered_hashmap::OrderedHashMap;
///
/// let mut map = OrderedHashMap::new();
/// assert_eq!(map.len(), 0);
///
/// map.insert(1, "one");
/// assert_eq!(map.len(), 1);
///
/// map.insert(2, "two");
/// assert_eq!(map.len(), 2);
/// ```
pub fn len(&self) -> usize {
self.map.len()
}
}
pub enum Entry<'a, K: 'a, V: 'a> {
Occupied(std::collections::hash_map::OccupiedEntry<'a, K, V>),
Vacant(std::collections::hash_map::VacantEntry<'a, K, V>),
}
impl<'a, K: Eq + Hash, V> Entry<'a, K, V> {
pub fn or_insert(self, default: V) -> &'a mut V {
match self {
Entry::Occupied(occupied) => occupied.into_mut(),
Entry::Vacant(vacant) => vacant.insert(default),
}
}
pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
match self {
Entry::Occupied(occupied) => occupied.into_mut(),
Entry::Vacant(vacant) => vacant.insert(default()),
}
}
}
impl<K: Eq + Hash + Clone, V> IntoIterator for OrderedHashMap<K, V> {
type Item = (K, V);
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
let mut extracted_items: Vec<(K, V)> = self.map.into_iter().collect();
self.keys
.into_iter()
.filter_map(move |k| {
if let Some(index) = extracted_items.iter().position(|(key, _)| *key == k) {
Some(extracted_items.remove(index))
} else {
None
}
})
.collect::<Vec<_>>()
.into_iter()
}
}