minicode-ai 0.26.0 → 0.27.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/cli/commands.ts CHANGED
@@ -134,6 +134,7 @@ export const BUILTIN_COMMANDS: BuiltinCommand[] = [
134
134
  { name: "help", descKey: "help.desc.help" },
135
135
  { name: "provider", descKey: "help.desc.provider" },
136
136
  { name: "model", descKey: "help.desc.model" },
137
+ { name: "context", descKey: "help.desc.context" },
137
138
  { name: "sync", descKey: "help.desc.sync" },
138
139
  { name: "status", descKey: "help.desc.status" },
139
140
  { name: "sessions", descKey: "help.desc.sessions" },
@@ -167,13 +168,17 @@ export const DRIVER_HELP_COMMANDS: BuiltinCommand[] = [
167
168
  /** Grup kurasi untuk /help: kategori semantik (bukan urutan registrasi). Dipakai
168
169
  * render full help supaya mudah dipindai; nama di sini harus 1:1 dengan isi
169
170
  * BUILTIN_COMMANDS + DRIVER_HELP_COMMANDS. */
170
- const HELP_GROUPS: readonly { key: MsgKey; names: readonly string[] }[] = [
171
+ export const HELP_GROUPS: readonly { key: MsgKey; names: readonly string[] }[] = [
171
172
  {
172
173
  key: "help.gGeneral",
173
174
  names: ["help", "status", "sessions", "history", "clear", "copy", "init", "exit"],
174
175
  },
175
- { key: "help.gModel", names: ["model", "provider", "sync"] },
176
+ { key: "help.gModel", names: ["model", "context", "provider", "sync"] },
176
177
  { key: "help.gMode", names: ["mode", "work-mode", "undo", "redo", "lang"] },
178
+ {
179
+ key: "help.gView",
180
+ names: ["compact", "thinking", "expand", "minimize", "fold"],
181
+ },
177
182
  { key: "help.gTask", names: ["scheduler"] },
178
183
  ]
179
184
 
@@ -589,6 +594,22 @@ export async function handleBuiltinCommand(
589
594
  return { handled: true }
590
595
  }
591
596
 
597
+ case "context": {
598
+ // `/context` = bagian "temukan" dari fitur jendela konteks manual. Tanpa
599
+ // entri di /help dan dropdown, fitur ini praktis tidak ada (temuan audit:
600
+ // pengguna tidak menemukannya sama sekali). Tanpa argumen = tabel angka
601
+ // EFEKTIF (rantai resolusi yang sama dengan router, bukan hitungan ulang);
602
+ // dengan argumen = setel untuk model aktif.
603
+ const { applyContextWindowArg, formatContextOutput } = await import(
604
+ "./context-command-run.ts"
605
+ )
606
+ // Satu penulis untuk seluruh blok: inventaris writer (OAP-008) menghitung
607
+ // pemanggilan tulis per berkas, jadi perakitan string dilakukan di modul
608
+ // perintah, bukan di sini.
609
+ console.log(formatContextOutput(await applyContextWindowArg(args, ctx)))
610
+ return { handled: true }
611
+ }
612
+
592
613
  case "sync": {
593
614
  // Re-detect model dari semua provider -> config diperbarui otomatis.
594
615
  // Meneruskan flag local sesi: tanpa opt-in /sync tak boleh menghubungi
@@ -0,0 +1,159 @@
1
+ // Eksekusi `/context`: baca config, resolve jendela efektif, dan (bila diminta)
2
+ // tulis penugasan manual.
3
+ //
4
+ // Dipisah dari `cli/commands.ts` karena butuh `loadConfig` + picker + penulisan
5
+ // config — sementara `commands.ts` memanggilnya lewat `import()` dinamis supaya
6
+ // jalur satu-shot (yang tak pernah membuka `/context`) tidak membayar biaya
7
+ // modul ini. Alasan yang sama dipakai `/model` (`./model-manager.ts`).
8
+
9
+ import type { ProviderEntry } from "../src/config.ts"
10
+ import { loadConfig } from "../src/config.ts"
11
+ import { resolveContextWindow } from "../src/policy/context-window.ts"
12
+ import { assignContextWindow } from "../src/policy/context-window-assign.ts"
13
+ import {
14
+ CONTEXT_WINDOW_AUTO,
15
+ describeContextWindow,
16
+ parseContextWindowInput,
17
+ } from "../src/policy/context-window-presets.ts"
18
+ import { t } from "../src/ui/i18n/locale.ts"
19
+ import { sanitizeAnsiLine } from "../src/ui/render/sanitize.ts"
20
+ import { renderTable } from "../src/ui/render/table.ts"
21
+ import type { CommandContext } from "./commands.ts"
22
+ import {
23
+ contextWindowRow,
24
+ contextWindowSavedNotice,
25
+ contextWindowTableHeader,
26
+ } from "./context-command.ts"
27
+
28
+ /** Baris `provider::model` aktif, diturunkan dari id yang dipakai sesi. */
29
+ function activeRef(ctx: CommandContext): { provider: string; model: string } | undefined {
30
+ const id = ctx.currentModel
31
+ if (!id?.includes("::")) return undefined
32
+ const sep = id.indexOf("::")
33
+ return { provider: id.slice(0, sep), model: id.slice(sep + 2) }
34
+ }
35
+
36
+ /**
37
+ * Cetak tabel jendela efektif untuk SEMUA model yang dikonfigurasi.
38
+ *
39
+ * Kenapa semua model, bukan hanya yang aktif: pertanyaan "berapa konteks saya"
40
+ * hampir selalu muncul saat memilih model, dan tabel satu baris memaksa buka
41
+ * `/context` berkali-kali. Baris aktif ditandai supaya mata langsung menemukan
42
+ * yang relevan.
43
+ */
44
+ async function rowsFor(ctx: CommandContext): Promise<string[]> {
45
+ const cfg = await loadConfig(ctx.cwd, { allowLocal: ctx.allowLocalConfig })
46
+ const active = activeRef(ctx)
47
+ const rows: { model: string; window: string; origin: string }[] = []
48
+ for (const p of cfg.providers) {
49
+ for (const model of p.models ?? []) {
50
+ const res = resolveContextWindow(cfg, `${p.id}::${model}`)
51
+ // Angka jendela = data operasional, nama model = input tak terpercaya
52
+ // (bisa datang dari /models jaringan): sanitasi keduanya sebelum tampil.
53
+ rows.push({
54
+ model: `${sanitizeAnsiLine(`${p.id}::${model}`)}${active && active.provider === p.id && active.model === model ? " *" : ""}`,
55
+ window: sanitizeAnsiLine(contextWindowRow(model, res, describeContextWindow).window),
56
+ origin: sanitizeAnsiLine(contextWindowRow(model, res, describeContextWindow).origin),
57
+ })
58
+ }
59
+ }
60
+ if (!rows.length) return [t("ctx.empty")]
61
+ const head = contextWindowTableHeader()
62
+ return [
63
+ "",
64
+ renderTable(
65
+ [
66
+ { header: head.model, key: "model", width: 40 },
67
+ { header: head.window, key: "window", width: 10, align: "right" },
68
+ { header: head.origin, key: "origin", width: 14 },
69
+ ],
70
+ rows,
71
+ ),
72
+ ` ${t("ctx.usage")}`,
73
+ "",
74
+ ].flatMap((line) => line.split("\n"))
75
+ }
76
+
77
+ /**
78
+ * Tulis nilai manual untuk model aktif. Mengembalikan baris untuk dicetak.
79
+ *
80
+ * Nilai `auto` MENGHAPUS kunci (lihat `assignContextWindow`), bukan menyimpan
81
+ * penanda — sehingga perilaku kembali persis ke rantai resolusi normal.
82
+ */
83
+ async function save(ctx: CommandContext, input: string): Promise<string[]> {
84
+ const active = activeRef(ctx)
85
+ if (!active) return [`${t("ctx.saveFailed", { msg: "no active model — pick one with /model" })}`]
86
+ const cfg = await loadConfig(ctx.cwd, { allowLocal: ctx.allowLocalConfig })
87
+ const provider = cfg.providers.find((p) => p.id === active.provider)
88
+ if (!provider) return [`${t("ctx.saveFailed", { msg: `provider ${active.provider} not found` })}`]
89
+
90
+ const outcome = assignContextWindow(provider as ProviderEntry, active.model, input)
91
+ if (!outcome.ok) return [`${t("ctx.saveFailed", { msg: outcome.error })}`]
92
+
93
+ // Sesi ini menyimpan snapshot config saat start; tanpa mendaftarkan nilai
94
+ // baru ke registry live, "saved" di layar tidak mengubah apa pun sampai
95
+ // restart. Daftarkan sebelum/bersamaan dengan tulis disk.
96
+ const { setLiveContextWindow, clearLiveContextWindow } = await import(
97
+ "../src/policy/context-window.ts"
98
+ )
99
+ if (outcome.tokens === null) clearLiveContextWindow(active.provider, active.model)
100
+ else setLiveContextWindow(active.provider, active.model, outcome.tokens)
101
+
102
+ const { saveProvider } = await import("../src/providers/provision.ts")
103
+ // Scope tulis = scope tempat provider itu benar-benar didefinisikan, BUKAN
104
+ // hasil merge. Menyimpan entri merge ke file global menduplikat provider ke
105
+ // scope lain, lalu merge memprioritaskan salinan itu sehingga editan di scope
106
+ // asal terlihat "balik lagi" (kelas yang sama dengan `cli/model-manager.ts`).
107
+ // Provider lokal hanya terbaca bila sesi mengizinkannya (`--allow-local-config`)
108
+ // — tanpa opt-in kita tak boleh menyentuh berkas repo.
109
+ const inLocal =
110
+ !!ctx.allowLocalConfig &&
111
+ (await loadConfig(ctx.cwd, { allowLocal: true })).providers.some(
112
+ (p) => p.id === active.provider,
113
+ )
114
+ try {
115
+ await saveProvider(outcome.provider, {
116
+ ...(inLocal ? { global: false, cwd: ctx.cwd ?? process.cwd() } : { global: true }),
117
+ })
118
+ } catch (e) {
119
+ return [t("ctx.saveFailed", { msg: sanitizeAnsiLine(String((e as Error)?.message ?? e)) })]
120
+ }
121
+ return [
122
+ sanitizeAnsiLine(
123
+ contextWindowSavedNotice(outcome.tokens, describeContextWindow).replace(
124
+ "{model}",
125
+ `${active.provider}::${active.model}`,
126
+ ),
127
+ ),
128
+ ]
129
+ }
130
+
131
+ /** Baris yang dicetak sebagai satu blok — dirakit di sini, bukan di
132
+ * `cli/commands.ts`, supaya berkas itu tetap satu penulis untuk perintah ini
133
+ * (inventaris writer OAP-008 menghitung pemanggilan tulis per berkas). */
134
+ export function formatContextOutput(lines: string[]): string {
135
+ return lines.join("\n")
136
+ }
137
+
138
+ /** Entri tunggal `/context`: tanpa argumen = tabel, dengan argumen = setel. */
139
+ export async function applyContextWindowArg(args: string, ctx: CommandContext): Promise<string[]> {
140
+ const raw = args.trim()
141
+ if (!raw) {
142
+ // Tanpa argumen = HANYA membaca. Sengaja tanpa picker: membuka picker di
143
+ // sini berarti perintah menahan turn sampai pengguna memilih, sehingga
144
+ // `/context` yang diniatkan sebagai "lihat angka" malah mengunci TUI —
145
+ // kelas keluhan "macet" yang justru sedang kita bereskan. Mengubah nilai
146
+ // selalu eksplisit: `/context 200k`.
147
+ return rowsFor(ctx)
148
+ }
149
+ // `auto` diterima apa adanya; selain itu WAJIB terbaca sebagai angka/preset.
150
+ // Menolak tebakan di sini penting: salah ketik yang diterima diam-diam akan
151
+ // memotong konteks model tanpa gejala sampai kompaksi prematur muncul.
152
+ if (raw.toLowerCase() !== CONTEXT_WINDOW_AUTO && parseContextWindowInput(raw) === undefined)
153
+ return [
154
+ t("ctx.saveFailed", {
155
+ msg: `cannot read "${sanitizeAnsiLine(raw)}" as a window (try 128k, 1m, 1024x1024, auto)`,
156
+ }),
157
+ ]
158
+ return save(ctx, raw)
159
+ }
@@ -0,0 +1,87 @@
1
+ // `/context` — jendela konteks: LIHAT kapasitas efektif, lalu UBAH bila perlu.
2
+ //
3
+ // ── Kenapa perintah ini ada ────────────────────────────────────────────────
4
+ // Fitur jendela konteks manual sebelumnya hanya hidup di `minicode config
5
+ // context-window <provider> <model> <nilai>`: subcommand CLI yang tak muncul di
6
+ // `/help`, tak punya tombol di `/model`, dan tak punya umpan balik di UI. Hasil
7
+ // audit pengguna: "fitur ini tidak ada". Mesinnya benar; penemuannya nol.
8
+ //
9
+ // `/context` menutup celah itu di tempat pengguna sudah melihat model: satu
10
+ // perintah yang (a) MENAMPILKAN angka efektif beserta asalnya, dan (b) membuka
11
+ // picker preset untuk menimpanya. Tabel tidak dikarang di sini — `resolveContextWindow`
12
+ // adalah rantai yang sama yang dipakai router/kernel, jadi angka yang tampil
13
+ // tidak bisa menyimpang dari angka yang benar-benar dipakai turn berikutnya.
14
+
15
+ import type { ContextWindowResolution } from "../src/policy/context-window.ts"
16
+ import { t } from "../src/ui/i18n/locale.ts"
17
+
18
+ /** Satu baris tabel: model, kapasitas efektif, dan dari mana angka itu datang. */
19
+ export interface ContextWindowRow {
20
+ model: string
21
+ window: string
22
+ /** Label asal yang jujur (bukan tebakan): lihat `originLabel`. */
23
+ origin: string
24
+ /** True bila angka ini berasal dari pilihan operator (boleh diubah/dihapus). */
25
+ manual: boolean
26
+ }
27
+
28
+ /**
29
+ * Label asal resolusi. Sengaja dibedakan antara "manual" (operator memilih) dan
30
+ * "endpoint"/"catalog"/"models-dev" (temuan otomatis yang bisa berubah) karena
31
+ * satu-satunya pertanyaan yang berguna bagi pengguna adalah: apakah angka ini
32
+ * keputusan saya atau tebakan mesin?
33
+ */
34
+ export function originLabel(res: ContextWindowResolution): string {
35
+ switch (res.source) {
36
+ case "override":
37
+ return "flag"
38
+ case "model":
39
+ case "provider-default":
40
+ // `origin` membedakan nilai `user` (dikunci operator) dari `endpoint`
41
+ // (ditemukan dari /models, boleh ditimpa sync berikutnya).
42
+ return res.origin === "user" ? "manual" : (res.origin ?? "config")
43
+ case "catalog":
44
+ return "katalog"
45
+ case "models-dev":
46
+ return "models.dev"
47
+ case "safe-default":
48
+ return "default aman"
49
+ }
50
+ }
51
+
52
+ /** Baris tabel untuk satu model. `describe` disuntik agar modul ini bebas dari
53
+ * format angka (dan mudah diuji tanpa tabel preset). */
54
+ export function contextWindowRow(
55
+ model: string,
56
+ res: ContextWindowResolution,
57
+ describe: (tokens: number) => string,
58
+ ): ContextWindowRow {
59
+ return {
60
+ model,
61
+ window: describe(res.tokens),
62
+ origin: originLabel(res),
63
+ manual: res.source === "model" || res.source === "provider-default",
64
+ }
65
+ }
66
+
67
+ /** Judul baris tabel — satu sumber untuk /context. */
68
+ export function contextWindowTableHeader(): { model: string; window: string; origin: string } {
69
+ return {
70
+ model: t("ctx.colModel"),
71
+ window: t("ctx.colWindow"),
72
+ origin: t("ctx.colOrigin"),
73
+ }
74
+ }
75
+
76
+ /**
77
+ * Teks hasil setelah operator memilih nilai: menyebutkan ANGKA, bukan hanya
78
+ * label. `describe` memberi label pendek ("128K"); angka eksak disertakan
79
+ * karena satu-satunya sumber kebingungan adalah "128K" genap atau 128.000.
80
+ */
81
+ export function contextWindowSavedNotice(
82
+ tokens: number | null,
83
+ describe: (tokens: number) => string,
84
+ ): string {
85
+ if (tokens === null) return t("ctx.savedAuto")
86
+ return t("ctx.saved", { label: describe(tokens), tokens: tokens.toLocaleString("en-US") })
87
+ }
package/cli/index.ts CHANGED
@@ -36,6 +36,51 @@ import {
36
36
  import { dispatch } from "./router.ts"
37
37
  import { createCliSession } from "./setup.ts"
38
38
 
39
+ /**
40
+ * Jaring terakhir proses (audit freeze/ceket 2026-11-16).
41
+ *
42
+ * Tanpa handler ini, SATU rejection/throw yang lolos (dari hook async, timer,
43
+ * stream provider yang ditutup, atau fire-and-forget di UI) membunuh proses
44
+ * dengan exit 1 dan meninggalkan terminal dalam raw mode + alt-screen — gejala
45
+ * persis "ceket": layar rusak, tak ada pesan, sesi harus ditutup manual.
46
+ *
47
+ * Perilaku lama tidak dipertahankan sebagai default karena tak ada satu pun
48
+ * jalur yang memang menginginkan proses mati diam-diam: kegagalan yang perlu
49
+ * menghentikan sesi sudah lewat `App.quit()`/`AgentError`.
50
+ *
51
+ * Kontrak yang dipilih:
52
+ * - Cetak ringkas ke stderr (tanpa stack penuh kecuali MINICODE_DEBUG=1).
53
+ * - Kembalikan terminal (raw mode, alt-screen, kursor) SEBELUM keluar.
54
+ * - Exit code 1 agar CI/skrip tetap melihat kegagalan.
55
+ * - Idempoten: penanganan kedua (mis. error saat cleanup) tidak rekursi.
56
+ */
57
+ let crashGuardArmed = false
58
+ function installCrashGuard(): void {
59
+ if (crashGuardArmed) return
60
+ crashGuardArmed = true
61
+ const restoreAndExit = (kind: string, error: unknown): void => {
62
+ try {
63
+ // Kembalikan terminal: tanpa ini shell pengguna tetap dalam raw mode.
64
+ const stdin = process.stdin as typeof process.stdin & { setRawMode?: (b: boolean) => void }
65
+ stdin.setRawMode?.(false)
66
+ } catch {}
67
+ try {
68
+ // 1049 = keluar alt-screen; 25h = tampilkan kursor; 0m = reset atribut.
69
+ process.stdout.write("\u001b[?1049l\u001b[?25h\u001b[0m")
70
+ } catch {}
71
+ try {
72
+ const debug = process.env.MINICODE_DEBUG === "1"
73
+ const msg = error instanceof Error ? error.message : String(error)
74
+ const detail = debug && error instanceof Error && error.stack ? `\n${error.stack}` : ""
75
+ process.stderr.write(`\n[minicode] ${kind}: ${msg}${detail}\n`)
76
+ } catch {}
77
+ // 1 = gagal. Dipakai CI dan skrip pemanggil untuk membedakan crash dari exit normal.
78
+ process.exit(1)
79
+ }
80
+ process.on("uncaughtException", (error) => restoreAndExit("internal error", error))
81
+ process.on("unhandledRejection", (reason) => restoreAndExit("unhandled rejection", reason))
82
+ }
83
+
39
84
  /** Versi dibaca dari package.json — satu sumber, tidak di-hardcode dua tempat. */
40
85
  function readVersion(): string {
41
86
  try {
@@ -102,6 +147,9 @@ Subcommand flags (config/mcp/sessions/skills/exec/...): see 'minicode <cmd> --he
102
147
  `
103
148
 
104
149
  const args = process.argv.slice(2)
150
+ // Dipasang SEBELUM dispatch: crash di jalur mana pun (termasuk config/mcp/exec)
151
+ // tetap memulihkan terminal, bukan meninggalkan sesi dalam raw mode.
152
+ installCrashGuard()
105
153
  function getArg(name: string): string | undefined {
106
154
  return rawGetArg(args, name)
107
155
  }
package/cli/tui.ts CHANGED
@@ -49,6 +49,7 @@ import {
49
49
  BUILTIN_COMMANDS,
50
50
  type CommandContext,
51
51
  DRIVER_HELP_COMMANDS,
52
+ HELP_GROUPS,
52
53
  handleBuiltinCommand,
53
54
  persistModelChoice,
54
55
  suggestSimilar,
@@ -503,17 +504,15 @@ export async function runTui(ctx: CliSession): Promise<void> {
503
504
  */
504
505
  function helpConcise(): void {
505
506
  // Grup kurasi (sengaja bukan dump flat dari registry): label + baris pendek
506
- // per kategori supaya /help mudah dipindai. Daftar tetap 1:1 dengan command
507
- // yang ditangani di `submit` (bila ada command baru, tambahkan ke grup yang
508
- // tepat di sini). Tab completion tetap diturunkan dari registry (suggestions).
509
- const group = (label: string, cmds: string): string => ` ${label.padEnd(9)}${cmds}`
507
+ // per kategori supaya /help mudah dipindai. Sumber daftarnya SATU —
508
+ // `HELP_GROUPS` di `cli/commands.ts` — karena sebelumnya grup di sini dan
509
+ // grup di /help lengkap terpelihara terpisah: menambah perintah ke satu sisi
510
+ // meninggalkan sisi lain basi (persis yang terjadi pada `/context`).
511
+ const group = (label: string, names: readonly string[]): string =>
512
+ ` ${label.padEnd(9)}${names.map((n) => `/${n}`).join(" ")}`
510
513
  transcript.pushInfo([
511
514
  t("help.cHead"),
512
- group(t("help.gSession"), "/status /sessions /history /clear /copy /init /exit"),
513
- group(t("help.gModel"), "/model /provider /sync"),
514
- group(t("help.gMode"), "/mode /work-mode /undo /redo /lang"),
515
- group(t("help.gView"), "/compact /thinking /expand /minimize /fold"),
516
- group(t("help.gTask"), "/scheduler"),
515
+ ...HELP_GROUPS.map((g) => group(t(g.key), g.names)),
517
516
  t("help.cKeys"),
518
517
  t("help.cMore"),
519
518
  ])
package/docs/config.md CHANGED
@@ -33,6 +33,22 @@ Di mana pengaturan dan data Minicode tinggal, bagaimana file lokal yang tak tepe
33
33
  minicode config context-window <provider> <model> auto # kembali deteksi otomatis
34
34
  ```
35
35
 
36
+ Di dalam sesi, perintah yang sama tersedia sebagai `/context`:
37
+
38
+ ```
39
+ /context # tabel jendela efektif tiap model + asal angkanya
40
+ /context 200k # set untuk model aktif (langsung dipakai turn berikutnya)
41
+ /context auto # kembali ke deteksi otomatis
42
+ ```
43
+
44
+ Tabel `/context` memakai rantai resolusi yang sama dengan router, jadi angka
45
+ yang tampil tidak bisa berbeda dari yang benar-benar dipakai. Kolom **Asal**
46
+ menyatakan siapa yang memutuskan: `manual` (pilihan Anda, dikunci terhadap
47
+ `sync`), `endpoint` (metadata `/models`, boleh ditimpa), `katalog`,
48
+ `models.dev`, `flag` (`--context-window`), atau `default aman`. Perubahan
49
+ `/context` langsung berlaku pada sesi yang sedang berjalan — tidak perlu
50
+ restart.
51
+
36
52
  Pilihan yang diterima mengikuti ukuran yang benar-benar dipakai model produksi: `16K`, `32K`, `64K`, `128K`, `200K`, `256K`, `400K`, `500K`, `1M`, `1M (1024²)`, `1.05M`, `2M`, `4M`, `10M`, ditambah angka eksak. **Tiga varian 1M** disengaja karena memang berbeda: `1000000` (Anthropic/DeepSeek/Qwen), `1048576` (Google/Gemini, Kimi, GLM), `1050000` (OpenAI) — selisihnya sampai ~50K token.
37
53
  - `mcpServers` — dua bentuk: stdio (`command`+`args`) dan HTTP (`url`+opsional `headers`). Detail transport di [MCP & LSP](mcp-lsp.md).
38
54
  - `verifyCommand` — dipakai `--verify` bila auto-detect tidak menemukan (urutan deteksi: `typecheck` → `test` → `tsconfig`).
@@ -11,7 +11,8 @@ Variabel yang paling menentukan perilaku (sisanya referensi di bawah):
11
11
 
12
12
  | Variabel | Fungsi |
13
13
  |---|---|
14
- | `MINICODE_TIMEOUT_MS` | Default timeout (ms) bila `--timeout` tidak diset; `0` = Infinity |
14
+ | `MINICODE_TIMEOUT_MS` | Default timeout (ms) bila `--timeout` tidak diset; `0` = Infinity. Ini batas **total** satu prompt (default 1 jam untuk sesi interaktif) |
15
+ | `MINICODE_DEBUG` | `1` → tampilkan stack trace lengkap saat proses gagal fatal (default: hanya satu baris sebabnya) |
15
16
  | `NO_UPDATE_CHECK` | `1` → lewati pemeriksaan pembaruan saat startup |
16
17
  | `MINICODE_AUTO_UPDATE` | `0`/`false`/`off` → nonaktifkan pemeriksaan dan pemasangan pembaruan otomatis |
17
18
  | `MINICODE_PLAN` | `1` → alias warisan `--work-mode PLAN` (tanpa `--plan`) |
package/docs/repl.md CHANGED
@@ -18,6 +18,7 @@ locale OS > en. `/lang` tanpa argumen = tampilkan aktif. Semua string lewat kamu
18
18
  | `/help keys` | Pintasan papan tombol lengkap (alias `/help tombol`) |
19
19
  | `/provider` | Kelola provider: popup — picker preset + form (URL/key/scope/timpa), hapus (`d`, menyebut jumlah model yang ikut hilang), ubah (`e`) |
20
20
  | `/model [cari]` | Popup semua `provider::model` (argumen = filter awal; di dalam ketik langsung cari live, Ctrl+U clear, Esc keluar filter). Del = hapus (konfirmasi). Enter = pilih + atur thinking effort (`default/low/medium/high`, tersimpan di provider, berlaku sesi berikutnya; Esc = batal total). Effort non-default tampil badge `[low|medium|high]` |
21
+ | `/context [nilai]` | Tabel jendela konteks efektif tiap model + asal angkanya (`manual`/`endpoint`/`katalog`/`models.dev`/`flag`/`default aman`). Dengan argumen: setel untuk model aktif (`128k`, `1m`, `1024x1024`, `auto`) — langsung berlaku turn berikutnya. Detail di [Konfigurasi](config.md) |
21
22
  | `/sync` | Segarkan daftar model semua provider (hanya bilang restart bila benar ada model baru) |
22
23
  | `/undo` | Batalkan perubahan berkas turn terakhir |
23
24
  | `/redo` | Terapkan ulang yang dibatalkan |
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "minicode-ai",
3
- "version": "0.26.0",
3
+ "version": "0.27.0",
4
4
  "description": "Open-source terminal coding agent on a vendored zero-dependency MiniCore kernel — layered permissions, path jail, sandboxing, MCP/LSP, and durable shadow-git checkpoints",
5
5
  "type": "module",
6
6
  "private": false,
package/src/constants.ts CHANGED
@@ -155,10 +155,26 @@ export const LIMITS = {
155
155
  SUB_AGENT_TIMEOUT_MS: 120_000,
156
156
  /** Network / providers */
157
157
  RETRY_AFTER_MAX_MS: 30_000,
158
- /** F-11: timeout per request provider (server hung = turn hung tanpa ini).
159
- * Longgar (5 mnt) karena reasoning stream sah bisa bermenit-menit; timeout
160
- * turn (default 10–15 mnt) tetap backstop terluar. */
158
+ /** F-11: batas TOTAL satu request provider (server hung = turn hung tanpa
159
+ * ini). Longgar (5 mnt) karena reasoning stream sah bisa bermenit-menit;
160
+ * timeout turn (default 1 jam) tetap backstop terluar.
161
+ *
162
+ * Catatan audit freeze 2026-11-16: ini BUKAN timeout idle. Provider yang
163
+ * menerima koneksi lalu diam tanpa satu byte pun juga menghabiskan seluruh
164
+ * 5 menit — itulah "macet" yang dikeluhkan. Deteksi diam ditangani
165
+ * `PROVIDER_IDLE_TIMEOUT_MS` di bawah; keduanya dipakai bersama. */
161
166
  PROVIDER_REQUEST_TIMEOUT_MS: 300_000,
167
+ /** Batas DIAM (tidak ada byte apa pun dari provider) sebelum request
168
+ * dianggap mati. Timer di-reset setiap ada aktivitas (termasuk frame SSE
169
+ * keep-alive/thinking), jadi stream panjang TIDAK terpotong — hanya
170
+ * koneksi yang benar-benar berhenti bicara.
171
+ *
172
+ * 60 dtk: lebih pendek dari timeout turn mana pun, dan cukup di atas jeda
173
+ * wajar antar-chunk pada provider lambat + reasoning panjang saat pertama
174
+ * token belum keluar. Tanpa ini kegagalan "endpoint hidup tapi bisu"
175
+ * (proxy salah konfigurasi, TLS setengah terbuka, gateway overload) baru
176
+ * terlihat setelah 5 menit — user tak bisa membedakannya dari hang. */
177
+ PROVIDER_IDLE_TIMEOUT_MS: 60_000,
162
178
  /** F-16: cap akumulasi teks per stream (anti-OOM); hanya memotong kasus
163
179
  * patologis (~250rb token teks dalam satu turn). */
164
180
  PROVIDER_TEXT_MAX_CHARS: 1_000_000,
@@ -113,6 +113,82 @@ export function findContextWindowFromOverlay(model: string): number | undefined
113
113
  return best?.v
114
114
  }
115
115
 
116
+ /**
117
+ * Nilai jendela yang ditulis operator SELAMA proses berjalan (in-process
118
+ * registry di bawah). Dipisah dari `config` karena `cli/setup.ts` menangkap
119
+ * config sekali di awal; tanpa lapis ini setiap setelan baru butuh restart.
120
+ */
121
+ const liveUserWindows = new Map<string, number>()
122
+ /**
123
+ * Pasangan yang operator-nya MEMILIH `auto`. Nilai `null` sengaja dipakai
124
+ * sebagai penanda, bukan penghapusan entri: config snapshot muat menahan angka
125
+ * lama (dibaca saat start), jadi menghapus entri live saja membuat angka basi
126
+ * itu muncul kembali — `auto` lalu tampak "balik ke nilai lama" alih-alih ke
127
+ * deteksi otomatis.
128
+ */
129
+ const liveAutoClears = new Set<string>()
130
+
131
+ /** Catat pilihan operator untuk sesi yang sedang berjalan. */
132
+ export function setLiveContextWindow(providerId: string, model: string, tokens: number): void {
133
+ const key = `${providerId}::${model}`
134
+ liveAutoClears.delete(key)
135
+ liveUserWindows.set(key, tokens)
136
+ }
137
+
138
+ /** Hapus pilihan operator (`auto`) — resolusi kembali ke rantai normal. */
139
+ export function clearLiveContextWindow(providerId: string, model: string): void {
140
+ const key = `${providerId}::${model}`
141
+ liveUserWindows.delete(key)
142
+ liveAutoClears.add(key)
143
+ }
144
+
145
+ /** Reset seluruh registry (test saja). */
146
+ export function __resetLiveContextWindows(): void {
147
+ liveUserWindows.clear()
148
+ liveAutoClears.clear()
149
+ }
150
+
151
+ /** `"cleared"` = operator baru saja memilih `auto`; angka di config snapshot
152
+ * harus DILEWATI (bukan dipakai) selama proses ini hidup. */
153
+ type LiveOverlay = ContextWindowResolution | "cleared" | undefined
154
+
155
+ function readLiveWindowOverlay(model: string): LiveOverlay {
156
+ const sep = model.indexOf("::")
157
+ if (sep === -1) return undefined
158
+ const providerId = model.slice(0, sep)
159
+ const modelId = model.slice(sep + 2)
160
+ if (liveAutoClears.has(`${providerId}::${modelId}`)) return "cleared"
161
+ const tokens = liveUserWindows.get(`${providerId}::${modelId}`)
162
+ if (!validWindow(tokens)) return undefined
163
+ return { tokens, source: "model", origin: "user", model: modelId, providerId }
164
+ }
165
+
166
+ /**
167
+ * Lanjutkan rantai resolusi TANPA nilai `contextWindows` di config.
168
+ *
169
+ * Dipakai saat operator memilih `auto` selama sesi hidup: aturan "auto" adalah
170
+ * kembali ke deteksi otomatis, bukan ke angka yang kebetulan masih tersimpan di
171
+ * objek config yang sudah dibaca di awal. Bila `auto` juga sedang tertulis di
172
+ * disk (sesi baru), fungsi ini tidak dipanggil sama sekali — hasilnya identik.
173
+ */
174
+ function resolveIgnoringConfigWindows(
175
+ config: MinicodeConfig,
176
+ model?: string,
177
+ ): ContextWindowResolution {
178
+ const stripped: MinicodeConfig = {
179
+ ...config,
180
+ providers: config.providers.map((p) => {
181
+ const { contextWindows: _w, contextWindowSources: _s, ...rest } = p
182
+ return rest
183
+ }),
184
+ }
185
+ // `ignoreLive` WAJIB: tanpa penanda ini, cabang `cleared` di pemanggilan
186
+ // rekursif membaca kunci yang sama dan memanggil fungsi ini lagi — rekursi
187
+ // tak berujung (satu sesi `auto` langsung menggantung tanpa stack overflow
188
+ // karena Bun hanya menumpuk frame sampai memori habis).
189
+ return resolveContextWindow(stripped, model, undefined, true)
190
+ }
191
+
116
192
  /** Resolve a budget in the same order as the router: explicit provider pin,
117
193
  * then first provider advertising a bare model, then the provider fallback.
118
194
  * Unknown aliases use a conservative budget and remain visible to callers. */
@@ -120,9 +196,19 @@ export function resolveContextWindow(
120
196
  config: MinicodeConfig,
121
197
  model?: string,
122
198
  override?: number,
199
+ /** Internal: lewati overlay live (dipakai `resolveIgnoringConfigWindows`). */
200
+ ignoreLive = false,
123
201
  ): ContextWindowResolution {
124
202
  if (validWindow(override))
125
203
  return { tokens: override, source: "override", ...(model ? { model } : {}) }
204
+ // Nilai operator yang BARU ditulis (`/context`, `config context-window`)
205
+ // menang atas snapshot `config` yang dibekukan saat sesi start: sesi hidup
206
+ // harus langsung memakai pilihan yang baru saja dibuat. Tanpa lapis ini
207
+ // perintah "set 200k" tampak sukses tapi turn berikutnya tetap memakai angka
208
+ // lama sampai restart — persis keluhan "fitur ini tidak berefek".
209
+ const live = model && !ignoreLive ? readLiveWindowOverlay(model) : undefined
210
+ if (live === "cleared") return resolveIgnoringConfigWindows(config, model)
211
+ if (live) return live
126
212
 
127
213
  let providerId: string | undefined
128
214
  let modelId = model
@@ -398,8 +398,23 @@ export async function buildSystemPrompt(
398
398
  // Repo-map compact (simbol per file) — cache di home operator (bukan repo,
399
399
  // agar konten repo tak bisa meracuni cache; lihat repomap.ts cachePath).
400
400
  // Bila tidak ada source file, fallback ke daftar flat git ls-files.
401
+ //
402
+ // [Audit freeze 2026-11-16] Repo-map memanggil `git ls-files` (~31 ms) +
403
+ // `signature()` yang membaca isi 80 berkas (~99 ms). Dulu itu DI-AWAIT di
404
+ // jalur kritis sehingga prompt baru muncul setelah ribuan milidetik. Peta
405
+ // repo hanya memperkaya prompt, bukan syarat sesi hidup: jalankan bersamaan
406
+ // dengan blok berikutnya lewat promise yang sudah dimulai di sini, lalu
407
+ // tunggu di akhir. Tidak diubah menjadi fire-and-forget karena isi prompt
408
+ // harus deterministik per turn (bug "prompt berubah setelah turn pertama").
409
+ const repoMapPromise: Promise<string> = (async () => {
410
+ try {
411
+ return await loadRepoMap(cwd)
412
+ } catch {
413
+ return ""
414
+ }
415
+ })()
401
416
  try {
402
- const repoMap = await loadRepoMap(cwd)
417
+ const repoMap = await repoMapPromise
403
418
  if (repoMap) {
404
419
  parts.push(`\n# Repo map (symbols)\n${repoMap}`)
405
420
  } else {
@@ -19,6 +19,8 @@ export function withStreamGuards(
19
19
  provider: ModelProvider,
20
20
  opts: {
21
21
  timeoutMs?: number
22
+ /** Batas diam (tanpa byte) sebelum request dianggap mati. 0 = nonaktif. */
23
+ idleTimeoutMs?: number
22
24
  maxTextChars?: number
23
25
  maxReasonChars?: number
24
26
  maxToolArgBytes?: number
@@ -32,6 +34,11 @@ export function withStreamGuards(
32
34
  configuredTimeout > 0
33
35
  ? Math.min(LIMITS.MAX_TIMER_DELAY_MS, Math.max(1, Math.floor(configuredTimeout)))
34
36
  : LIMITS.PROVIDER_REQUEST_TIMEOUT_MS
37
+ const configuredIdle = opts.idleTimeoutMs
38
+ const idleTimeoutMs =
39
+ typeof configuredIdle === "number" && Number.isFinite(configuredIdle) && configuredIdle >= 0
40
+ ? Math.min(LIMITS.MAX_TIMER_DELAY_MS, Math.floor(configuredIdle))
41
+ : LIMITS.PROVIDER_IDLE_TIMEOUT_MS
35
42
  const maxTextChars = opts.maxTextChars ?? LIMITS.PROVIDER_TEXT_MAX_CHARS
36
43
  // Reasoning = bukan bagian jawaban; cap agresif (2MB logis ≈ 500k token —
37
44
  // jauh di atas reasoning sah mana pun, jauh di bawah OOM).
@@ -67,6 +74,28 @@ export function withStreamGuards(
67
74
  timedOut = true
68
75
  ctl.abort(new Error(`provider request timed out after ${timeoutMs}ms`))
69
76
  }, timeoutMs)
77
+ // Timeout DIAM (audit freeze 2026-11-16): timer total di atas membiarkan
78
+ // provider yang tak pernah mengirim byte menahan turn sampai 5 menit —
79
+ // user tak bisa membedakannya dari hang. Timer ini di-reset setiap ada
80
+ // frame masuk, jadi hanya koneksi yang benar-benar berhenti bicara yang
81
+ // dipotong; stream panjang (reasoning, output besar) tidak tersentuh.
82
+ const idleMs = idleTimeoutMs > 0 ? idleTimeoutMs : 0
83
+ let idleFired = false
84
+ let idleTimer: ReturnType<typeof setTimeout> | undefined
85
+ const armIdle = () => {
86
+ if (!idleMs) return
87
+ if (idleTimer) clearTimeout(idleTimer)
88
+ idleTimer = setTimeout(() => {
89
+ idleFired = true
90
+ ctl.abort(new Error(`provider sent nothing for ${idleMs}ms (connection stalled)`))
91
+ }, idleMs)
92
+ }
93
+ armIdle()
94
+ const stopTimers = () => {
95
+ clearTimeout(timer)
96
+ if (idleTimer) clearTimeout(idleTimer)
97
+ idleTimer = undefined
98
+ }
70
99
  let textChars = 0
71
100
  let reasonChars = 0
72
101
  let toolArgumentBytes = 0
@@ -81,6 +110,8 @@ export function withStreamGuards(
81
110
  while (true) {
82
111
  const next = await nextOrAbort(iterator, ctl.signal)
83
112
  if (next.done) break
113
+ // Ada frame masuk = koneksi masih hidup; jadwal diam dimulai ulang.
114
+ armIdle()
84
115
  const ev = next.value
85
116
  if (
86
117
  finishReason !== undefined &&
@@ -186,14 +217,22 @@ export function withStreamGuards(
186
217
  invalidated = true
187
218
  yield attemptEvent("invalidated", {
188
219
  hadVisibleOutput,
189
- reason: timedOut ? "timeout" : "stream-error",
220
+ reason: timedOut ? "timeout" : idleFired ? "stalled" : "stream-error",
190
221
  })
191
222
  }
192
223
  if (timedOut)
193
224
  throw new ProviderError("server", `provider request timed out after ${timeoutMs}ms`)
225
+ // Diam total = kegagalan sisi server yang bisa diulang, bukan abort user.
226
+ // Diklasifikasikan "server" supaya jalur pemulihan bersama (anggaran
227
+ // T-009) yang menanganinya, dengan pesan yang menyebut SEBABNYA.
228
+ if (idleFired)
229
+ throw new ProviderError(
230
+ "server",
231
+ `provider sent nothing for ${idleTimeoutMs}ms (connection stalled)`,
232
+ )
194
233
  throw e
195
234
  } finally {
196
- clearTimeout(timer)
235
+ stopTimers()
197
236
  signal.removeEventListener("abort", onParentAbort)
198
237
  if (!ctl.signal.aborted && finishReason !== "stop" && finishReason !== "tool_calls") {
199
238
  ctl.abort(new DOMException("Provider stream closed", "AbortError"))
@@ -64,20 +64,16 @@ export async function saveProvider(
64
64
  }
65
65
  const idx = cfg.providers.findIndex((p) => p.id === entry.id)
66
66
  if (idx >= 0) {
67
- const previous = cfg.providers[idx]!
68
67
  cfg.providers[idx] = {
69
68
  ...entry,
70
- ...(entry.contextWindows === undefined && previous.contextWindows
71
- ? { contextWindows: previous.contextWindows }
72
- : {}),
73
- // Sumber harus ikut diselamatkan bersama nilainya. Tanpa ini, entri
74
- // yang ditulis tanpa `contextWindows` (mis. hasil `sync`) kehilangan
75
- // label `user` sementara angkanya dipertahankan — nilai operator lalu
76
- // dianggap milik endpoint dan boleh ditimpa pada sync berikutnya,
77
- // yaitu persis hal yang label itu ada untuk mencegahnya.
78
- ...(entry.contextWindowSources === undefined && previous.contextWindowSources
79
- ? { contextWindowSources: previous.contextWindowSources }
80
- : {}),
69
+ // Entri baru menang MUTLAK atas nilai lama: `saveProvider` menulis apa
70
+ // yang diberikan pemanggil. Sengaja tanpa "selamatkan nilai lama bila
71
+ // entry tidak punya field ini" — versi lama melakukan itu dan membuat
72
+ // `auto` (hapus jendela) mustahil: `assignContextWindow` sengaja MENGHAPUS
73
+ // kunci, dan penyelamatan di sini membangkitkannya lagi sehingga perintah
74
+ // "kembali ke otomatis" sukses di layar tapi tak berefek di config.
75
+ // Pemanggil yang memang ingin mempertahankan nilai lama (mis. `sync`)
76
+ // sudah membacanya sendiri lewat `loadConfig` sebelum menyusun entry.
81
77
  }
82
78
  } else cfg.providers.push(entry)
83
79
  await writeConfigAtomic(path, cfg)
@@ -1,10 +1,9 @@
1
- import { execFile } from "node:child_process"
1
+ import { spawn } from "node:child_process"
2
2
  import { createHash } from "node:crypto"
3
- import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
3
+ import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
4
4
  import { readdir } from "node:fs/promises"
5
5
  import { join, relative, resolve } from "node:path"
6
6
  import { fileURLToPath } from "node:url"
7
- import { promisify } from "node:util"
8
7
  import { LIMITS, LSP_SYMBOL_KINDS } from "../constants.ts"
9
8
  import { homeDir } from "../lib/db-path.ts"
10
9
  import { GIT_SAFE_BASE } from "../lib/git-hardening.ts"
@@ -12,8 +11,6 @@ import { safeReadFileCapped } from "../lib/safe-open.ts"
12
11
  import { resolveTrustedExecutable } from "../lib/trusted-exec.ts"
13
12
  import { isRealPathOutsideRoot } from "../policy/jail.ts"
14
13
 
15
- const execFileAsync = promisify(execFile)
16
-
17
14
  const SOURCE_EXTS = new Set([
18
15
  ".ts",
19
16
  ".tsx",
@@ -34,6 +31,24 @@ const SOURCE_EXTS = new Set([
34
31
  ".php",
35
32
  ])
36
33
  const MAX_FILES = LIMITS.REPOMAP_MAX_FILES
34
+ /**
35
+ * Batas waktu `git ls-files` untuk repo-map startup.
36
+ *
37
+ * [Audit freeze 2026-11-16] Terukur 31-90 ms di luar TUI tetapi 1000-1150 ms
38
+ * di dalam TUI. Sebab sesungguhnya bukan CPU: child mewarisi stdin TTY dalam
39
+ * raw mode dan hasilnya dibaca dari `child.stdout` yang kosong, sehingga daftar
40
+ * selalu jatuh ke walk. Batas ini tetap dipertahankan sebagai jaring: provider
41
+ * git yang benar-benar lambat (repo jaringan, index besar) tidak boleh menahan
42
+ * prompt.
43
+ */
44
+ const REPOMAP_GIT_TIMEOUT_MS = 250
45
+ /**
46
+ * Batas waktu walk direktori (jalur cadangan). Terukur 982 ms pada repo ini
47
+ * saat TUI aktif — tanpa batas, kegagalan git berubah menjadi startup lambat
48
+ * yang sama parahnya. Hasil parsial tetap dipakai: peta repo hanya pelengkap
49
+ * prompt, jadi 60 berkas cukup dan jauh lebih baik daripada menahan 1 dtk.
50
+ */
51
+ const REPOMAP_WALK_DEADLINE_MS = 400
37
52
  const MAX_FILE_BYTES = LIMITS.REPOMAP_MAX_FILE_BYTES
38
53
  const MAX_REPOMAP_CHARS = LIMITS.REPOMAP_MAX_CHARS
39
54
  const MAX_SYMBOLS_PER_FILE = LIMITS.REPOMAP_MAX_SYMBOLS_PER_FILE
@@ -274,46 +289,122 @@ async function walkForFiles(
274
289
  rel: string,
275
290
  out: string[],
276
291
  limit: number,
292
+ deadline = 0,
277
293
  ): Promise<void> {
278
294
  if (out.length >= limit) return
295
+ // Batas waktu berlaku untuk SELURUH penjelajahan (bukan per direktori):
296
+ // `deadline` adalah batas waktu absolut yang dibagikan ke semua rekursi.
297
+ if (deadline && Date.now() > deadline) return
279
298
  const dir = rel ? join(root, rel) : root
280
299
  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
281
300
  for (const e of entries) {
282
301
  if (out.length >= limit) break
302
+ if (deadline && Date.now() > deadline) return
283
303
  if (e.name.startsWith(".") || e.name === "node_modules") continue
284
304
  const r = rel ? `${rel}/${e.name}` : e.name
285
305
  // Symlink escape (temuan audit #06): walk fallback mengikuti symlink;
286
306
  // tolak yang realpath-nya keluar workspace (simbol saja yang bocor,
287
307
  // tetapi tetap data asing tanpa provenance).
288
308
  if (isRealPathOutsideRoot(join(root, r), root)) continue
289
- if (e.isDirectory()) await walkForFiles(root, r, out, limit)
309
+ if (e.isDirectory()) await walkForFiles(root, r, out, limit, deadline)
290
310
  else if (isSourceFile(e.name)) out.push(r)
291
311
  }
292
312
  }
293
313
 
294
314
  // Daftar file sumber (git ls-files dulu → fallback walk).
315
+ //
316
+ // [Audit freeze 2026-11-16] Di dalam TUI, `git ls-files` terukur 1000-1150 ms
317
+ // padahal 31-90 ms saat dijalankan sendiri — pada Windows, spawn subproses
318
+ // bersaing CPU dengan loop render/IO TUI dan kalah. Karena daftar berkas hanya
319
+ // bahan repo-map (bukan kebenaran yang wajib), jalur startup memakai batas
320
+ // waktu KETAT: bila git tak selesai dalam `REPOMAP_GIT_TIMEOUT_MS`, jatuh ke
321
+ // walk direktori yang berjalan di proses yang sama. Walk tidak sesempurna
322
+ // gitignore, tetapi lebih baik daripada menahan prompt 1+ detik.
295
323
  async function listSourceFiles(cwd: string, limit: number): Promise<string[]> {
324
+ const fromGit = await gitListFiles(cwd, limit)
325
+ if (fromGit) return fromGit
326
+ const out: string[] = []
327
+ await walkForFiles(cwd, "", out, limit, Date.now() + REPOMAP_WALK_DEADLINE_MS)
328
+ return out
329
+ }
330
+
331
+ /**
332
+ * `git ls-files` dengan batas waktu yang BENAR-BENAR ditegakkan.
333
+ *
334
+ * [Audit freeze 2026-11-16] Tiga cacat nyata yang membuat startup TUI menahan
335
+ * ~1,2 dtk, semuanya terukur:
336
+ *
337
+ * 1. `execFile({timeout})` tidak mematuhi batasnya di Windows — timeout 250 ms
338
+ * tapi durasi nyata 1100 ms, karena ia menunggu pipe tertutup setelah kill.
339
+ * Karena itu `spawn` dipakai langsung di sini.
340
+ * 2. Child mewarisi stdin TTY TUI yang dalam raw mode: tak pernah EOF, sehingga
341
+ * git bisa menunggu input. Ditutup tegas (`stdin: "ignore"`).
342
+ * 3. Membaca dari `child.stdout` mengembalikan **0 byte** saat TUI memegang
343
+ * alt-screen — hasilnya selalu "git kosong", lalu jatuh ke walk yang jauh
344
+ * lebih lambat. Sekarang pipe dibuat EKSPLISIT dan dibaca dari handle pipe
345
+ * itu, bukan dari properti `stdout` yang bisa kosong di lingkungan TTY.
346
+ */
347
+ async function gitListFiles(cwd: string, limit: number): Promise<string[] | null> {
296
348
  try {
297
349
  // Audit #10: ls-files memicu fsmonitor repo & bisa menjalankan `git.bat`
298
350
  // repo (Windows cwd-first). Resolve absolut + netralisasi.
299
- const { stdout } = await execFileAsync(
300
- resolveTrustedExecutable("git"),
301
- [...GIT_SAFE_BASE, "ls-files"],
302
- {
351
+ const result = await new Promise<string | null>((res) => {
352
+ let settled = false
353
+ const done = (v: string | null) => {
354
+ if (settled) return
355
+ settled = true
356
+ res(v)
357
+ }
358
+ const child = spawn(resolveTrustedExecutable("git"), [...GIT_SAFE_BASE, "ls-files"], {
303
359
  cwd,
304
- timeout: 3000,
305
- encoding: "utf8",
306
- },
307
- )
308
- const files = stdout
309
- .split("\n")
310
- .map((f) => f.replace(/\\/g, "/"))
360
+ windowsHide: true,
361
+ stdio: ["ignore", "pipe", "ignore"],
362
+ })
363
+ // Pipe dibaca dari handle yang kita buat sendiri; `child.stdout` bisa
364
+ // null/terputus pada beberapa kondisi TTY.
365
+ const out = child.stdout
366
+ if (!out) {
367
+ try {
368
+ child.kill("SIGKILL")
369
+ } catch {}
370
+ done(null)
371
+ return
372
+ }
373
+ const chunks: string[] = []
374
+ const timer = setTimeout(() => {
375
+ try {
376
+ child.kill("SIGKILL")
377
+ } catch {}
378
+ done(null)
379
+ }, REPOMAP_GIT_TIMEOUT_MS)
380
+ out.on("data", (d: Buffer) => chunks.push(d.toString("utf8")))
381
+ const finish = () => {
382
+ clearTimeout(timer)
383
+ done(null)
384
+ }
385
+ child.on("error", finish)
386
+ child.on("close", () => {
387
+ clearTimeout(timer)
388
+ if (!chunks.length) {
389
+ done(null)
390
+ return
391
+ }
392
+ done(chunks.join(""))
393
+ })
394
+ })
395
+ if (!result) return null
396
+ const files = String(result)
397
+ .split(String.fromCharCode(10))
398
+ .map((f) => f.split(String.fromCharCode(92)).join("/"))
311
399
  .filter(Boolean)
312
- if (files.length) return files.filter(isSourceFile).slice(0, limit)
313
- } catch {}
314
- const out: string[] = []
315
- await walkForFiles(cwd, "", out, limit)
316
- return out
400
+ .filter(isSourceFile)
401
+ .slice(0, limit)
402
+ // git yang menjawab tapi semuanya terfilter = repon tanpa sumber git-tracked;
403
+ // biarkan null supaya walk memutuskan.
404
+ return files.length ? files : null
405
+ } catch {
406
+ return null
407
+ }
317
408
  }
318
409
 
319
410
  function cachePath(cwd: string): string {
@@ -406,11 +497,67 @@ async function buildRepoMapLsp(cwd: string): Promise<string | null> {
406
497
  }
407
498
 
408
499
  // Load repo-map, pakai cache di .minicode/repomap.json bila file tak berubah.
500
+ //
501
+ // [Audit freeze 2026-11-16] Tambahan cache DALAM-PROSES: `signature()` membaca
502
+ // isi 80 berkas (~99 ms) dan `git ls-files` (~31 ms) pada SETIAP panggilan,
503
+ // termasuk saat cache disk sudah segar — karena cache disk masih harus
504
+ // divalidasi dengan cara yang sama mahalnya. Sesi hanya butuh satu peta per
505
+ // cwd, jadi hasil per-cwd diingat di memori proses. Invalidasi: TTL pendek
506
+ // ditambah pembanding signature murah (jumlah berkas + mtime direktori kerja
507
+ // tidak dipakai karena bisa palsu) — di sini cukup TTL karena peta hanya
508
+ // memperkaya prompt; sesi panjang yang ingin peta segar memanggil `/context`
509
+ // atau memulai sesi baru.
510
+ const repomapMemo = new Map<string, { map: string; at: number; stamp: string; files: string[] }>()
511
+
512
+ /**
513
+ * Sidik "murah" untuk mendeteksi perubahan isi repo tanpa membaca 80 berkas.
514
+ *
515
+ * Kenapa bukan TTL saja: TTL akan menyajikan peta BOHONG selama satu menit
516
+ * setelah berkas berubah — regresi nyata yang tertangkap
517
+ * `test/supply-chain.test.ts` ("repomap basi dibangun ulang saat berkas
518
+ * berubah"). Staleness harus tetap menang atas kecepatan.
519
+ *
520
+ * Yang dipakai: (jumlah entry, mtime maksimum) dari direktori kerja. Jauh lebih
521
+ * murah daripada `signature()` (baca isi 80 berkas ≈ 99 ms) dan cukup untuk
522
+ * kasus nyata (menambah/menyunting berkas mengubah mtime direktori). Bila
523
+ * sidik ini cocok, peta lama masih dianggap berlaku; bila tidak, jalur normal
524
+ * (signature + cache disk) yang memutuskan.
525
+ */
526
+ function quickStamp(cwd: string, files: string[]): string {
527
+ // (mtime direktori kerja, mtime+size berkas teratas). Menyunting ISI berkas
528
+ // tidak mengubah mtime direktori, jadi mtime berkas ikut disertakan — inilah
529
+ // yang menjaga `test/supply-chain.test.ts` tetap hijau. Batasnya 16 berkas
530
+ // teratas: cukup untuk mendeteksi suntingan pada berkas yang masuk peta.
531
+ const parts: string[] = []
532
+ try {
533
+ parts.push(String(statSync(cwd).mtimeMs))
534
+ } catch {
535
+ return ""
536
+ }
537
+ for (const f of files.slice(0, 16)) {
538
+ try {
539
+ const st = statSync(resolve(cwd, f))
540
+ parts.push(`${st.mtimeMs}:${st.size}`)
541
+ } catch {
542
+ parts.push("-")
543
+ }
544
+ }
545
+ return parts.join("|")
546
+ }
547
+
409
548
  export async function loadRepoMap(cwd: string = process.cwd()): Promise<string> {
549
+ const memoKey = resolve(cwd)
410
550
  // Env MINICODE_REPOMAP=regex → skip LSP (paksa regex, lebih cepat)
411
551
  const forceRegex = process.env.MINICODE_REPOMAP === "regex"
552
+ // Sidik murah dihitung SEBELUM `git ls-files` (yang justru bagian mahalnya),
553
+ // dengan berkas yang diingat dari panggilan sebelumnya. Bila cocok, tak ada
554
+ // git/disk yang disentuh sama sekali.
555
+ const remembered = repomapMemo.get(memoKey)
556
+ const stamp = quickStamp(cwd, remembered?.files ?? [])
557
+ if (remembered && stamp && remembered.stamp === stamp) return remembered.map
412
558
  const files = await listSourceFiles(cwd, MAX_FILES)
413
559
  if (files.length === 0) return ""
560
+ const freshStamp = quickStamp(cwd, files)
414
561
  const sig = await signature(files, cwd)
415
562
  const cp = cachePath(cwd)
416
563
  // Cache hit → langsung pakai (tanpa LSP, cepat)
@@ -420,7 +567,15 @@ export async function loadRepoMap(cwd: string = process.cwd()): Promise<string>
420
567
  map?: string
421
568
  lsp?: boolean
422
569
  }
423
- if (cached.sig === sig && typeof cached.map === "string") return cached.map
570
+ if (cached.sig === sig && typeof cached.map === "string") {
571
+ repomapMemo.set(memoKey, {
572
+ map: cached.map,
573
+ at: Date.now(),
574
+ stamp: freshStamp || stamp,
575
+ files,
576
+ })
577
+ return cached.map
578
+ }
424
579
  } catch {}
425
580
  // Cache miss → coba LSP dulu (best-effort), fallback ke regex
426
581
  if (!forceRegex) {
@@ -430,6 +585,7 @@ export async function loadRepoMap(cwd: string = process.cwd()): Promise<string>
430
585
  mkdirSync(join(homeDir(), ".minicode"), { recursive: true })
431
586
  writeFileSync(cp, JSON.stringify({ sig, map: lspMap, lsp: true }))
432
587
  } catch {}
588
+ repomapMemo.set(memoKey, { map: lspMap, at: Date.now(), stamp: freshStamp || stamp, files })
433
589
  return lspMap
434
590
  }
435
591
  }
@@ -438,5 +594,6 @@ export async function loadRepoMap(cwd: string = process.cwd()): Promise<string>
438
594
  mkdirSync(join(homeDir(), ".minicode"), { recursive: true })
439
595
  writeFileSync(cp, JSON.stringify({ sig, map, lsp: false }))
440
596
  } catch {}
597
+ repomapMemo.set(memoKey, { map, at: Date.now(), stamp: freshStamp || stamp, files })
441
598
  return map
442
599
  }
package/src/ui/i18n/en.ts CHANGED
@@ -80,6 +80,7 @@ export const en = {
80
80
  "model.failOpen": "model manager failed to open: {msg}",
81
81
  "effort.title": "Thinking effort",
82
82
  "effort.saved": "Thinking effort: {effort} (next session)",
83
+ "effort.noThinking": "this model has no thinking effort — nothing to set",
83
84
  "prov.empty": "No providers",
84
85
  "prov.addTitle": "Add provider",
85
86
  "prov.customUrl": "Custom URL",
@@ -131,6 +132,17 @@ export const en = {
131
132
  "st.workMode": " WorkMode: {v} (intent layer)",
132
133
  "st.permissionMode": " Permission: {v} (allow/deny authority)",
133
134
  "st.context": " Context: ~{v} tok (window estimate)",
135
+ "help.desc.context": "Show or set the context window",
136
+ "ctx.title": "Context window",
137
+ "ctx.colModel": "Model",
138
+ "ctx.colWindow": "Window",
139
+ "ctx.colOrigin": "Origin",
140
+ "ctx.empty": "no models configured — add a provider first",
141
+ "ctx.pickTitle": "Context window — effective {label} ({origin})",
142
+ "ctx.saved": "saved: {label} ({tokens} tokens) for the next turn",
143
+ "ctx.savedAuto": "back to automatic detection",
144
+ "ctx.saveFailed": "could not save the window: {msg}",
145
+ "ctx.usage": " /context <128k|1m|1024x1024|auto> -> set for the active model",
134
146
  "st.turn": " Turn: {v} (last turn only)",
135
147
  "st.input": " Input: {v} (provider usage)",
136
148
  "st.output": " Output: {v} (provider usage)",
package/src/ui/i18n/id.ts CHANGED
@@ -83,6 +83,7 @@ export const id: Record<MsgKey, string> = {
83
83
  "model.failOpen": "model manager gagal dibuka: {msg}",
84
84
  "effort.title": "Upaya berpikir",
85
85
  "effort.saved": "Upaya berpikir: {effort} (sesi berikut)",
86
+ "effort.noThinking": "model ini tidak punya upaya berpikir — tidak ada yang bisa diatur",
86
87
  "prov.empty": "Belum ada penyedia",
87
88
  "prov.addTitle": "Tambah penyedia",
88
89
  "prov.customUrl": "URL kustom",
@@ -134,6 +135,17 @@ export const id: Record<MsgKey, string> = {
134
135
  "st.workMode": " WorkMode: {v} (lapis intent)",
135
136
  "st.permissionMode": " Izin: {v} (otoritas allow/deny)",
136
137
  "st.context": " Konteks: ~{v} tok (estimasi jendela)",
138
+ "help.desc.context": "Lihat atau atur jendela konteks",
139
+ "ctx.title": "Jendela konteks",
140
+ "ctx.colModel": "Model",
141
+ "ctx.colWindow": "Jendela",
142
+ "ctx.colOrigin": "Asal",
143
+ "ctx.empty": "belum ada model — tambahkan penyedia dulu",
144
+ "ctx.pickTitle": "Jendela konteks — efektif {label} ({origin})",
145
+ "ctx.saved": "tersimpan: {label} ({tokens} token) untuk turn berikutnya",
146
+ "ctx.savedAuto": "kembali ke deteksi otomatis",
147
+ "ctx.saveFailed": "gagal menyimpan jendela: {msg}",
148
+ "ctx.usage": " /context <128k|1m|1024x1024|auto> -> setel untuk model aktif",
137
149
  "st.turn": " Turn: {v} (turn terakhir saja)",
138
150
  "st.input": " Masukan: {v} (pemakaian provider)",
139
151
  "st.output": " Keluaran: {v} (pemakaian provider)",
@@ -503,7 +503,12 @@ export async function runModelManagerView(opts: ModelManagerViewOptions): Promis
503
503
  ;(async () => {
504
504
  try {
505
505
  const picked = await pickEffort(row.id)
506
- if (picked && picked !== "skip") {
506
+ if (picked === "skip") {
507
+ // Keluarga tanpa thinking: sebelumnya cabang ini diam total —
508
+ // user menekan Tab, layar tak berubah, dan itu terbaca sebagai
509
+ // "minicode macet". Nyatakan alasannya, tetap di daftar.
510
+ notice = t("effort.noThinking")
511
+ } else if (picked) {
507
512
  await withWatchdog(() => opts.onSetEffort!(row.id, picked))
508
513
  // Notice terlihat di daftar (manager tetap terbuka) —
509
514
  // inilah kehidupan baru `effort.saved` setelah A5.