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 +23 -2
- package/cli/context-command-run.ts +159 -0
- package/cli/context-command.ts +87 -0
- package/cli/index.ts +48 -0
- package/cli/tui.ts +8 -9
- package/docs/config.md +16 -0
- package/docs/environment.md +2 -1
- package/docs/repl.md +1 -0
- package/package.json +1 -1
- package/src/constants.ts +19 -3
- package/src/policy/context-window.ts +86 -0
- package/src/policy/context.ts +16 -1
- package/src/providers/guards.ts +41 -2
- package/src/providers/provision.ts +8 -12
- package/src/repo/repomap.ts +180 -23
- package/src/ui/i18n/en.ts +12 -0
- package/src/ui/i18n/id.ts +12 -0
- package/src/ui/screens/model-manager.ts +6 -1
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.
|
|
507
|
-
//
|
|
508
|
-
//
|
|
509
|
-
|
|
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(
|
|
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`).
|
package/docs/environment.md
CHANGED
|
@@ -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.
|
|
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:
|
|
159
|
-
* Longgar (5 mnt) karena reasoning stream sah bisa bermenit-menit;
|
|
160
|
-
* turn (default
|
|
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
|
package/src/policy/context.ts
CHANGED
|
@@ -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
|
|
417
|
+
const repoMap = await repoMapPromise
|
|
403
418
|
if (repoMap) {
|
|
404
419
|
parts.push(`\n# Repo map (symbols)\n${repoMap}`)
|
|
405
420
|
} else {
|
package/src/providers/guards.ts
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
//
|
|
74
|
-
//
|
|
75
|
-
//
|
|
76
|
-
//
|
|
77
|
-
//
|
|
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)
|
package/src/repo/repomap.ts
CHANGED
|
@@ -1,10 +1,9 @@
|
|
|
1
|
-
import {
|
|
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
|
|
300
|
-
|
|
301
|
-
|
|
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
|
-
|
|
305
|
-
|
|
306
|
-
}
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
.
|
|
310
|
-
|
|
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
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
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")
|
|
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
|
|
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.
|