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,119 @@
+//! Criterion benchmarks for scrollback search.
+//!
+//! - `scan` measures the raw regex scan over a large corpus — the work that ran
+//!   synchronously on the input thread on every keystroke before the background
+//!   daemon, and now runs off-thread.
+//! - `query_steady` / `query_cold` measure the UI-thread cost of `update_query`
+//!   after the daemon change: a steady keystroke only compiles the matcher and
+//!   enqueues the query (the scan is off-thread), while the cold path also
+//!   rebuilds and ships the corpus on a content change.
+
+use std::hint::black_box;
+use std::time::Duration;
+
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
+
+use kigi_tui::scrollback::{
+    RenderBlock, ScrollbackSearchIndex, ScrollbackSearchState, ScrollbackState,
+};
+use kigi_tui::search::{QueryKind, TextMatcher};
+
+/// Roughly the entry count of a long working session.
+const CORPUS_ENTRIES: usize = 30_000;
+
+/// Each measured iteration scans (or rebuilds) the whole corpus, so cap the
+/// sample count — criterion's default 100 would run for minutes.
+const SAMPLE_SIZE: usize = 10;
+
+/// One paragraph of body text per entry, so the whole corpus is on the order of
+/// a long session's searchable text (tens of MB; the exact size is logged).
+fn entry_body(i: usize) -> String {
+    let lorem = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do \
+                 eiusmod tempor incididunt ut labore et dolore magna aliqua ut \
+                 enim ad minim veniam quis nostrud exercitation ullamco laboris ";
+    format!(
+        "Entry {i}: the quick brown fox jumps over the lazy dog. {lorem}{lorem}{lorem} \
+         function foo_{i} calls bar_{i} and returns baz_{i} after work."
+    )
+}
+
+/// Build a large scrollback approximating a long session.
+fn build_large_scrollback(entries: usize) -> ScrollbackState {
+    let mut state = ScrollbackState::new();
+    let mut total_bytes = 0usize;
+    for i in 0..entries {
+        let body = entry_body(i);
+        total_bytes += body.len();
+        state.push_block(RenderBlock::user_prompt(body));
+    }
+    eprintln!(
+        "scrollback search corpus: {entries} entries, ~{:.1} MB searchable text",
+        total_bytes as f64 / (1024.0 * 1024.0)
+    );
+    state
+}
+
+/// The regex scan itself — the work the daemon now runs off the input thread
+/// (previously this ran synchronously per keystroke). `fox` appears in every
+/// entry, the worst case for match collection.
+fn bench_scan(c: &mut Criterion) {
+    let state = build_large_scrollback(CORPUS_ENTRIES);
+    let mut index = ScrollbackSearchIndex::new();
+    index.sync(&state);
+    let matcher = TextMatcher::new("fox", QueryKind::Regex);
+
+    let mut g = c.benchmark_group("search");
+    g.sample_size(SAMPLE_SIZE)
+        .warm_up_time(Duration::from_secs(1));
+    g.bench_function("scan", |b| {
+        b.iter(|| black_box(index.find(black_box(&matcher))));
+    });
+    g.finish();
+}
+
+/// Steady keystroke after the daemon: the corpus is already shipped, so
+/// `update_query` just compiles the matcher and enqueues the query, and `poll`
+/// picks up the async result — no scan on the UI thread.
+fn bench_query_steady(c: &mut Criterion) {
+    let state = build_large_scrollback(CORPUS_ENTRIES);
+    let mut search = ScrollbackSearchState::open();
+    // Ship the corpus once so the measured calls only enqueue (content unchanged).
+    search.update_query("warmup", &state);
+
+    let queries = ["fox", "baz", "lorem", "function"];
+    let mut g = c.benchmark_group("search");
+    g.sample_size(SAMPLE_SIZE)
+        .warm_up_time(Duration::from_secs(1));
+    g.bench_function("query_steady", |b| {
+        let mut n = 0usize;
+        b.iter(|| {
+            let q = queries[n % queries.len()];
+            n += 1;
+            search.update_query(q, &state);
+            search.poll();
+        });
+    });
+    g.finish();
+}
+
+/// Cold path: a fresh session, so `update_query` also rebuilds and ships the
+/// corpus (the per-entry searchable-text cache) before enqueueing the query.
+fn bench_query_cold(c: &mut Criterion) {
+    let state = build_large_scrollback(CORPUS_ENTRIES);
+    let mut g = c.benchmark_group("search");
+    g.sample_size(SAMPLE_SIZE)
+        .warm_up_time(Duration::from_secs(1));
+    g.bench_function("query_cold", |b| {
+        b.iter_batched(
+            ScrollbackSearchState::open,
+            |mut search| {
+                search.update_query("fox", &state);
+            },
+            BatchSize::SmallInput,
+        );
+    });
+    g.finish();
+}
+
+criterion_group!(benches, bench_scan, bench_query_steady, bench_query_cold);
+criterion_main!(benches);