rempug 0.0.0-stage → 0.1.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/.claude-plugin/plugin.json +6 -0
- package/.mcp.json +8 -0
- package/LICENSE +21 -0
- package/README.md +105 -2
- package/dist/src/cli.js +55 -0
- package/dist/src/commands.js +471 -0
- package/dist/src/core/agents.js +42 -0
- package/dist/src/core/bangun.js +21 -0
- package/dist/src/core/brief.js +91 -0
- package/dist/src/core/centang.js +34 -0
- package/dist/src/core/doctor.js +58 -0
- package/dist/src/core/errors.js +16 -0
- package/dist/src/core/git.js +35 -0
- package/dist/src/core/ledger.js +349 -0
- package/dist/src/core/paham.js +149 -0
- package/dist/src/core/probe.js +204 -0
- package/dist/src/core/profile.js +31 -0
- package/dist/src/core/registry.js +78 -0
- package/dist/src/core/reply.js +38 -0
- package/dist/src/core/report.js +96 -0
- package/dist/src/core/scan.js +58 -0
- package/dist/src/core/scope.js +103 -0
- package/dist/src/core/screen.js +74 -0
- package/dist/src/core/sections.js +25 -0
- package/dist/src/core/send.js +161 -0
- package/dist/src/core/tick.js +119 -0
- package/dist/src/core/tmux.js +33 -0
- package/dist/src/core/transport.js +48 -0
- package/dist/src/core/verify.js +306 -0
- package/dist/src/core/watch.js +51 -0
- package/dist/src/mcp.js +119 -0
- package/dist/src/runtime.js +31 -0
- package/hooks/hooks.json +15 -0
- package/package.json +63 -5
- package/skills/rempug/SKILL.md +82 -0
|
@@ -0,0 +1,149 @@
|
|
|
1
|
+
import { parseBrief } from "./brief.js";
|
|
2
|
+
import { RempugError, UsageError } from "./errors.js";
|
|
3
|
+
import { PROFIL_BAWAAN } from "./profile.js";
|
|
4
|
+
import { readAgents } from "./registry.js";
|
|
5
|
+
import { covers } from "./scope.js";
|
|
6
|
+
import { parseSections } from "./sections.js";
|
|
7
|
+
const LABELS = ["CAKUPAN", "CEK", "RENCANA", "ASUMSI", "PERTANYAAN"];
|
|
8
|
+
const MAKS_PUTARAN = 3;
|
|
9
|
+
const MAKS_BUTIR = 3;
|
|
10
|
+
/** Tindakan yang tidak boleh muncul di rencana agent. */
|
|
11
|
+
const TERLARANG = /\bgit\s+(commit|push|reset|checkout|stash|rebase|clean|merge|cherry-pick)\b|\brm\s+-[a-z]*r[a-z]*\b|\bsudo\b|--force\b|--no-verify\b/i;
|
|
12
|
+
const kosong = (teks) => !teks || /^(-|\(kosong\)|tidak ada)$/i.test(teks.trim());
|
|
13
|
+
const normalisasi = (path) => path.replace(/^(\.\/)+/, "").replace(/\/+$/, "");
|
|
14
|
+
function sama(a, b) {
|
|
15
|
+
const x = [...new Set(a)].sort();
|
|
16
|
+
const y = [...new Set(b)].sort();
|
|
17
|
+
return x.length === y.length && x.every((v, i) => v === y[i]);
|
|
18
|
+
}
|
|
19
|
+
const baris = (teks) => teks
|
|
20
|
+
.split("\n")
|
|
21
|
+
.map((l) => l.trim())
|
|
22
|
+
.filter(Boolean);
|
|
23
|
+
/** Path yang disebut di teks: token yang memuat `/` atau berakhiran ekstensi, bukan URL atau opsi. */
|
|
24
|
+
function pathDisebut(teks) {
|
|
25
|
+
return teks
|
|
26
|
+
.split(/[\s`'"(),;:]+/)
|
|
27
|
+
.map((t) => t.replace(/\.+$/, ""))
|
|
28
|
+
.filter((t) => t !== "" &&
|
|
29
|
+
!t.startsWith("-") &&
|
|
30
|
+
!t.includes("://") &&
|
|
31
|
+
(t.includes("/") || /\.[a-z][a-z0-9]{1,4}$/i.test(t)));
|
|
32
|
+
}
|
|
33
|
+
const potong = (teks, panjang) => teks.length > panjang ? `${teks.slice(0, panjang - 1)}…` : teks;
|
|
34
|
+
/** Alasan konfirmasi pemahaman tidak boleh disetujui otomatis; kosong berarti cocok. */
|
|
35
|
+
function bandingkan(task, bagian) {
|
|
36
|
+
const parsed = parseBrief(task.brief);
|
|
37
|
+
if (!parsed.ok || parsed.brief.cakupan.mode !== "edit")
|
|
38
|
+
throw new RempugError(`brief T${task.id} tersimpan tidak valid`);
|
|
39
|
+
const scope = parsed.brief.cakupan.paths;
|
|
40
|
+
const alasan = [];
|
|
41
|
+
const cakupan = (bagian.get("CAKUPAN") ?? "").split(/[\s,]+/).filter(Boolean);
|
|
42
|
+
if (cakupan[0] === "edit")
|
|
43
|
+
cakupan.shift();
|
|
44
|
+
if (!sama(cakupan.map(normalisasi), scope.map(normalisasi)))
|
|
45
|
+
alasan.push(`cakupan berbeda dari brief (agent: ${cakupan.join(", ") || "-"}; brief: ${scope.join(", ")})`);
|
|
46
|
+
const cek = kosong(bagian.get("CEK")) ? [] : baris(bagian.get("CEK") ?? "");
|
|
47
|
+
if (!sama(cek, parsed.brief.cek))
|
|
48
|
+
alasan.push("cek berbeda dari brief");
|
|
49
|
+
const rencanaTeks = bagian.get("RENCANA") ?? "";
|
|
50
|
+
const rencana = baris(rencanaTeks).map((l) => l.replace(/^(\d+[.)]|[-*•])\s+/, ""));
|
|
51
|
+
if (rencana.length > MAKS_BUTIR)
|
|
52
|
+
alasan.push(`rencana lebih dari ${MAKS_BUTIR} butir (${rencana.length})`);
|
|
53
|
+
const luar = pathDisebut(rencanaTeks).filter((p) => !covers(scope, p));
|
|
54
|
+
if (luar.length > 0)
|
|
55
|
+
alasan.push(`rencana menyentuh di luar cakupan: ${luar.join(", ")}`);
|
|
56
|
+
const terlarang = TERLARANG.exec(`${rencanaTeks}\n${bagian.get("ASUMSI") ?? ""}`);
|
|
57
|
+
if (terlarang)
|
|
58
|
+
alasan.push(`rencana memuat tindakan terlarang: ${terlarang[0]}`);
|
|
59
|
+
if (!kosong(bagian.get("ASUMSI")))
|
|
60
|
+
alasan.push(`asumsi: ${bagian.get("ASUMSI")}`);
|
|
61
|
+
if (!kosong(bagian.get("PERTANYAAN")))
|
|
62
|
+
alasan.push(`pertanyaan: ${bagian.get("PERTANYAAN")}`);
|
|
63
|
+
return { alasan, rencana };
|
|
64
|
+
}
|
|
65
|
+
/**
|
|
66
|
+
* Konfirmasi pemahaman dari agent. Disetujui otomatis (tanpa token orkestrator) bila isinya
|
|
67
|
+
* cocok dengan brief; selain itu tugas ditahan dan satu kejadian dikeluarkan.
|
|
68
|
+
*/
|
|
69
|
+
export function paham(ledger, id, teks) {
|
|
70
|
+
const task = ledger.getTask(id);
|
|
71
|
+
if (!task)
|
|
72
|
+
throw new RempugError(`tugas T${id} tidak ada`);
|
|
73
|
+
if (task.status !== "berjalan" && task.status !== "menunggu-klarifikasi")
|
|
74
|
+
throw new RempugError(`tugas T${id} berstatus ${task.status}; paham tidak berlaku`);
|
|
75
|
+
if (task.mode !== "edit") {
|
|
76
|
+
ledger.patch(id, { paham: teks });
|
|
77
|
+
return { hasil: "LANJUT" };
|
|
78
|
+
}
|
|
79
|
+
const { body, errors } = parseSections(teks, LABELS);
|
|
80
|
+
for (const label of LABELS)
|
|
81
|
+
if (!body.has(label))
|
|
82
|
+
errors.push(`bagian ${label} hilang`);
|
|
83
|
+
if (errors.length > 0)
|
|
84
|
+
throw new UsageError(`format paham salah:\n${errors.map((e) => `- ${e}`).join("\n")}`);
|
|
85
|
+
const { alasan, rencana } = bandingkan(task, body);
|
|
86
|
+
if (task.teliti)
|
|
87
|
+
alasan.push(`--teliti, rencana: ${rencana.join(" / ")}`);
|
|
88
|
+
if (alasan.length === 0) {
|
|
89
|
+
ledger.patch(id, { paham: teks });
|
|
90
|
+
return { hasil: "LANJUT" };
|
|
91
|
+
}
|
|
92
|
+
const putaran = task.putaran + 1;
|
|
93
|
+
if (putaran > MAKS_PUTARAN) {
|
|
94
|
+
ledger.setStatus(id, "gagal-paham");
|
|
95
|
+
ledger.addEvent(id, "gagal-paham", `T${id} ${task.agent} ✗ gagal-paham setelah ${MAKS_PUTARAN} putaran klarifikasi`);
|
|
96
|
+
return { hasil: "GAGAL-PAHAM" };
|
|
97
|
+
}
|
|
98
|
+
ledger.patch(id, { paham: teks, putaran });
|
|
99
|
+
ledger.setStatus(id, "menunggu-klarifikasi");
|
|
100
|
+
const ringkas = alasan.join("; ").replace(/\s*\n\s*/g, " ");
|
|
101
|
+
ledger.addEvent(id, "klarifikasi", potong(`T${id} ${task.agent} menunggu-klarifikasi: ${ringkas}`, 300));
|
|
102
|
+
return { hasil: "MENUNGGU", alasan: ringkas };
|
|
103
|
+
}
|
|
104
|
+
/**
|
|
105
|
+
* Jawaban orkestrator. Bila tugas menunggu klarifikasi, jawaban disimpan untuk diambil agent
|
|
106
|
+
* lewat `tunggu`; bila agent bertanya di obrolan (tugas berjalan), teksnya disuntikkan ke agent.
|
|
107
|
+
*/
|
|
108
|
+
export async function jawab(deps, id, teks) {
|
|
109
|
+
const task = deps.ledger.getTask(id);
|
|
110
|
+
if (!task)
|
|
111
|
+
throw new RempugError(`tugas T${id} tidak ada`);
|
|
112
|
+
if (task.status === "menunggu-klarifikasi") {
|
|
113
|
+
deps.ledger.patch(id, { jawaban: teks });
|
|
114
|
+
return "disimpan";
|
|
115
|
+
}
|
|
116
|
+
if (task.status === "berjalan") {
|
|
117
|
+
const agent = readAgents(deps.registryFile).find((a) => a.name === task.agent);
|
|
118
|
+
if (!agent)
|
|
119
|
+
throw new RempugError(`agent "${task.agent}" tidak terdaftar`);
|
|
120
|
+
await deps.transport.kirim(agent.tmux, teks, agent.kirim ?? PROFIL_BAWAAN);
|
|
121
|
+
return "dikirim";
|
|
122
|
+
}
|
|
123
|
+
throw new RempugError(`tugas T${id} berstatus ${task.status}; tidak ada yang dijawab`);
|
|
124
|
+
}
|
|
125
|
+
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
126
|
+
/** Agent menunggu jawaban; menahan paling lama `timeoutMs` dan aman diulang. */
|
|
127
|
+
export async function tunggu(ledger, id, options = {}) {
|
|
128
|
+
const { timeoutMs = 45_000, pollMs = 500 } = options;
|
|
129
|
+
const akhir = Date.now() + timeoutMs;
|
|
130
|
+
for (;;) {
|
|
131
|
+
const task = ledger.getTask(id);
|
|
132
|
+
if (!task)
|
|
133
|
+
throw new RempugError(`tugas T${id} tidak ada`);
|
|
134
|
+
if (task.status === "berjalan")
|
|
135
|
+
return "LANJUT";
|
|
136
|
+
if (task.status === "gagal-paham")
|
|
137
|
+
return `GAGAL-PAHAM: batas klarifikasi terlampaui; berhenti dan jalankan \`rempug reply T${id} --gagal\`.`;
|
|
138
|
+
if (task.status !== "menunggu-klarifikasi")
|
|
139
|
+
return `STOP: tugas berstatus ${task.status}.`;
|
|
140
|
+
if (task.jawaban) {
|
|
141
|
+
ledger.setStatus(id, "berjalan");
|
|
142
|
+
ledger.patch(id, { jawaban: null });
|
|
143
|
+
return `JAWABAN: ${task.jawaban}\nLANJUT`;
|
|
144
|
+
}
|
|
145
|
+
if (Date.now() >= akhir)
|
|
146
|
+
return `BELUM: belum ada jawaban; jalankan \`rempug tunggu T${id}\` lagi.`;
|
|
147
|
+
await sleep(pollMs);
|
|
148
|
+
}
|
|
149
|
+
}
|
|
@@ -0,0 +1,204 @@
|
|
|
1
|
+
import { spawnSync } from "node:child_process";
|
|
2
|
+
import { createHash } from "node:crypto";
|
|
3
|
+
import { RempugError } from "./errors.js";
|
|
4
|
+
import { KANDIDAT } from "./profile.js";
|
|
5
|
+
import { readAgents, updateAgent } from "./registry.js";
|
|
6
|
+
import { hashLayar, klasifikasi, tokenDiLayar } from "./screen.js";
|
|
7
|
+
import { pointer } from "./send.js";
|
|
8
|
+
import { listPanes } from "./tmux.js";
|
|
9
|
+
const BRIEF_PING = "TUJUAN: probe pengiriman\nCAKUPAN: baca\nLANGKAH:\n1. Tidak perlu melakukan apa pun selain membaca tugas ini.\nCEK: -\nBALASAN: -";
|
|
10
|
+
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
11
|
+
const sha1 = (teks) => createHash("sha1").update(teks).digest("hex");
|
|
12
|
+
/** Versi CLI agent (baris pertama `--version`), atau kosong bila tidak bisa dibaca. */
|
|
13
|
+
export function versiAgent(jenis) {
|
|
14
|
+
const hasil = spawnSync(jenis, ["--version"], {
|
|
15
|
+
encoding: "utf8",
|
|
16
|
+
timeout: 3000,
|
|
17
|
+
});
|
|
18
|
+
if (hasil.error || hasil.status !== 0)
|
|
19
|
+
return undefined;
|
|
20
|
+
return hasil.stdout
|
|
21
|
+
.split("\n")
|
|
22
|
+
.find((l) => l.trim() !== "")
|
|
23
|
+
?.trim();
|
|
24
|
+
}
|
|
25
|
+
/**
|
|
26
|
+
* Menunggu agent membaca brief. Model sungguhan bisa butuh puluhan detik, jadi selama layarnya masih
|
|
27
|
+
* berubah (agent bekerja) probe terus menunggu sampai batas atas; ia hanya menyerah bila lewat batas dasar
|
|
28
|
+
* dan layar sudah tenang. Spinner dan timer tidak dihitung sebagai perubahan.
|
|
29
|
+
*/
|
|
30
|
+
async function tungguAck(ledger, transport, target, id, batas) {
|
|
31
|
+
const mulai = Date.now();
|
|
32
|
+
const ambil = (lama) => {
|
|
33
|
+
try {
|
|
34
|
+
return hashLayar(transport.layar(target, 40));
|
|
35
|
+
}
|
|
36
|
+
catch {
|
|
37
|
+
return lama;
|
|
38
|
+
}
|
|
39
|
+
};
|
|
40
|
+
let hash = ambil("");
|
|
41
|
+
let berubahPada = mulai;
|
|
42
|
+
for (;;) {
|
|
43
|
+
if (ledger.getTask(id)?.ackedAt !== undefined)
|
|
44
|
+
return true;
|
|
45
|
+
const kini = Date.now();
|
|
46
|
+
if (kini - mulai >= batas.maksMs)
|
|
47
|
+
return false;
|
|
48
|
+
const baru = ambil(hash);
|
|
49
|
+
if (baru !== hash) {
|
|
50
|
+
hash = baru;
|
|
51
|
+
berubahPada = kini;
|
|
52
|
+
}
|
|
53
|
+
if (kini - mulai >= batas.dasarMs && kini - berubahPada >= batas.tenangMs)
|
|
54
|
+
return false;
|
|
55
|
+
await sleep(120);
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
const cuplik = (baris) => baris
|
|
59
|
+
.map((b) => b.trimEnd())
|
|
60
|
+
.filter(Boolean)
|
|
61
|
+
.slice(-30)
|
|
62
|
+
.join("\n");
|
|
63
|
+
/**
|
|
64
|
+
* Mengukur cara berkomunikasi dengan satu agent: teknik kirim yang benar-benar sampai (diuji lewat
|
|
65
|
+
* tugas `ping` yang harus dibaca agent), waktu ack, dan apakah layarnya beranimasi saat idle.
|
|
66
|
+
* Hasilnya disimpan di registry. Tidak pernah menjawab prompt izin atas nama user.
|
|
67
|
+
*/
|
|
68
|
+
export async function probeAgent(deps, nama) {
|
|
69
|
+
const { ledger, transport } = deps;
|
|
70
|
+
const agent = readAgents(deps.registryFile).find((a) => a.name === nama);
|
|
71
|
+
if (!agent)
|
|
72
|
+
throw new RempugError(`agent "${nama}" tidak terdaftar`);
|
|
73
|
+
if (!listPanes(deps.tmux).some((p) => p.target === agent.tmux))
|
|
74
|
+
throw new RempugError(`pane ${agent.tmux} milik agent "${nama}" tidak ada di tmux`);
|
|
75
|
+
const kandidat = deps.kandidat ?? KANDIDAT;
|
|
76
|
+
const batas = {
|
|
77
|
+
dasarMs: deps.ackTimeoutMs ?? 20_000,
|
|
78
|
+
tenangMs: deps.tenangMs ?? 4000,
|
|
79
|
+
maksMs: deps.ackMaksMs ?? 90_000,
|
|
80
|
+
};
|
|
81
|
+
const baseline = deps.baselineMs ?? 1500;
|
|
82
|
+
const hash = new Set();
|
|
83
|
+
for (let i = 0; i < 4; i++) {
|
|
84
|
+
hash.add(sha1(transport.tampak(agent.tmux).baris.join("\n")));
|
|
85
|
+
await sleep(baseline / 4);
|
|
86
|
+
}
|
|
87
|
+
const animasiIdle = hash.size > 1;
|
|
88
|
+
const versi = (deps.versi ?? versiAgent)(agent.kind) ?? agent.versi;
|
|
89
|
+
let dicoba = 0;
|
|
90
|
+
let alasan;
|
|
91
|
+
let hasil;
|
|
92
|
+
let layarAkhir = [];
|
|
93
|
+
for (const profil of kandidat) {
|
|
94
|
+
dicoba++;
|
|
95
|
+
const id = ledger.createTask({
|
|
96
|
+
repo: deps.repo,
|
|
97
|
+
agent: nama,
|
|
98
|
+
mode: "baca",
|
|
99
|
+
brief: BRIEF_PING,
|
|
100
|
+
});
|
|
101
|
+
ledger.setStatus(id, "berjalan");
|
|
102
|
+
const mulai = Date.now();
|
|
103
|
+
try {
|
|
104
|
+
await transport.kirim(agent.tmux, pointer(id), profil);
|
|
105
|
+
if (await tungguAck(ledger, transport, agent.tmux, id, batas)) {
|
|
106
|
+
const ackMs = Date.now() - mulai;
|
|
107
|
+
await sleep(Math.min(1500, baseline));
|
|
108
|
+
const baris = transport
|
|
109
|
+
.tampak(agent.tmux)
|
|
110
|
+
.baris.filter((b) => b.trim() !== "");
|
|
111
|
+
const penandaSiap = /^\s*([^\p{L}\p{N}\s]{1,4})/u.exec(baris.at(-1) ?? "")?.[1];
|
|
112
|
+
hasil = { nama, status: "siap", profil, ackMs, dicoba };
|
|
113
|
+
updateAgent(deps.registryFile, nama, {
|
|
114
|
+
kirim: profil,
|
|
115
|
+
tidakAndal: false,
|
|
116
|
+
versi,
|
|
117
|
+
gagalBeruntun: 0,
|
|
118
|
+
catatan: undefined,
|
|
119
|
+
ukur: { ackMs, animasiIdle, penandaSiap, probeAt: ledger.now() },
|
|
120
|
+
});
|
|
121
|
+
return hasil;
|
|
122
|
+
}
|
|
123
|
+
const { baris, kursorY } = transport.tampak(agent.tmux);
|
|
124
|
+
layarAkhir = baris;
|
|
125
|
+
const token = `rempug brief T${id}`;
|
|
126
|
+
const keadaan = klasifikasi({ baris, kursorY, berubah: false, token });
|
|
127
|
+
if (keadaan === "menunggu-izin") {
|
|
128
|
+
hasil = {
|
|
129
|
+
nama,
|
|
130
|
+
status: "perlu-izin",
|
|
131
|
+
dicoba,
|
|
132
|
+
catatan: `agent menunggu izin menjalankan rempug: setujui sekali di sesi ${agent.tmux} (pilih izinkan selalu), lalu ulangi /rempug`,
|
|
133
|
+
};
|
|
134
|
+
break;
|
|
135
|
+
}
|
|
136
|
+
if (keadaan === "error") {
|
|
137
|
+
hasil = {
|
|
138
|
+
nama,
|
|
139
|
+
status: "tidak-andal",
|
|
140
|
+
dicoba,
|
|
141
|
+
catatan: "agent melaporkan galat (limit, kuota, atau autentikasi); periksa `layar <agent>`, lalu login atau coba lagi nanti",
|
|
142
|
+
};
|
|
143
|
+
break;
|
|
144
|
+
}
|
|
145
|
+
if (keadaan === "tertahan")
|
|
146
|
+
alasan = "tertahan";
|
|
147
|
+
else if (tokenDiLayar(baris, token)) {
|
|
148
|
+
// Teks ada di riwayat percakapan: agent menerimanya, jadi tidak boleh dikirim ulang.
|
|
149
|
+
hasil = {
|
|
150
|
+
nama,
|
|
151
|
+
status: "tanpa-ack",
|
|
152
|
+
dicoba,
|
|
153
|
+
catatan: "pointer diterima tetapi agent tidak menjalankan rempug (kemungkinan: `rempug` tidak ada di PATH shell agent, agent menunggu izin, atau tidak mengikuti protokol; lihat `layar <agent>`)",
|
|
154
|
+
};
|
|
155
|
+
break;
|
|
156
|
+
}
|
|
157
|
+
else
|
|
158
|
+
alasan = "dibuang";
|
|
159
|
+
await transport.tekan(agent.tmux, ["C-u"]);
|
|
160
|
+
}
|
|
161
|
+
finally {
|
|
162
|
+
ledger.deleteTask(id);
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
hasil ??= {
|
|
166
|
+
nama,
|
|
167
|
+
status: "tidak-andal",
|
|
168
|
+
dicoba,
|
|
169
|
+
catatan: alasan === "tertahan"
|
|
170
|
+
? `teks tertahan di kotak input; ${dicoba} kombinasi dicoba`
|
|
171
|
+
: `teks tidak pernah muncul di layar; ${dicoba} kombinasi dicoba`,
|
|
172
|
+
};
|
|
173
|
+
hasil.cuplikan = cuplik(layarAkhir);
|
|
174
|
+
if (hasil.status !== "perlu-izin")
|
|
175
|
+
updateAgent(deps.registryFile, nama, {
|
|
176
|
+
tidakAndal: true,
|
|
177
|
+
catatan: hasil.catatan,
|
|
178
|
+
versi,
|
|
179
|
+
ukur: { ...agent.ukur, animasiIdle, probeAt: ledger.now() },
|
|
180
|
+
});
|
|
181
|
+
return hasil;
|
|
182
|
+
}
|
|
183
|
+
/** Profil usang bila versi CLI agent berubah atau pengiriman gagal berturut-turut dua kali. */
|
|
184
|
+
export function isStale(agent, versiSekarang) {
|
|
185
|
+
if ((agent.gagalBeruntun ?? 0) >= 2)
|
|
186
|
+
return true;
|
|
187
|
+
return (agent.versi !== undefined &&
|
|
188
|
+
versiSekarang !== undefined &&
|
|
189
|
+
agent.versi !== versiSekarang);
|
|
190
|
+
}
|
|
191
|
+
/** Memprobe ulang agent hanya bila profilnya usang; mengembalikan `undefined` bila tidak perlu. */
|
|
192
|
+
export async function reprobeJikaUsang(deps, nama, versiSekarang) {
|
|
193
|
+
const agent = readAgents(deps.registryFile).find((a) => a.name === nama);
|
|
194
|
+
if (!agent || !isStale(agent, versiSekarang))
|
|
195
|
+
return undefined;
|
|
196
|
+
return probeAgent(deps, nama);
|
|
197
|
+
}
|
|
198
|
+
/** Satu baris kesiapan agent untuk laporan `/rempug`. */
|
|
199
|
+
export function formatProbe(hasil) {
|
|
200
|
+
const nama = hasil.nama.padEnd(10);
|
|
201
|
+
if (hasil.status === "siap")
|
|
202
|
+
return `${nama}✓ siap ack ${((hasil.ackMs ?? 0) / 1000).toFixed(1)} dtk`;
|
|
203
|
+
return `${nama}✗ ${hasil.status} ${hasil.catatan ?? ""}`.trimEnd();
|
|
204
|
+
}
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
export const PROFIL_BAWAAN = {
|
|
2
|
+
suntik: "keys",
|
|
3
|
+
sebelum: [],
|
|
4
|
+
submit: ["Enter"],
|
|
5
|
+
jeda_ms: 400,
|
|
6
|
+
};
|
|
7
|
+
/** Kombinasi yang dicoba berurutan saat probe; urutan dari yang paling umum. */
|
|
8
|
+
export const KANDIDAT = [
|
|
9
|
+
PROFIL_BAWAAN,
|
|
10
|
+
{ suntik: "paste", sebelum: [], submit: ["Enter"], jeda_ms: 400 },
|
|
11
|
+
{ suntik: "keys", sebelum: ["C-u"], submit: ["Enter"], jeda_ms: 400 },
|
|
12
|
+
{
|
|
13
|
+
suntik: "keys",
|
|
14
|
+
sebelum: ["C-u"],
|
|
15
|
+
submit: ["Enter", "Enter"],
|
|
16
|
+
jeda_ms: 600,
|
|
17
|
+
},
|
|
18
|
+
{ suntik: "paste", sebelum: ["C-u"], submit: ["Enter"], jeda_ms: 600 },
|
|
19
|
+
{
|
|
20
|
+
suntik: "paste",
|
|
21
|
+
sebelum: ["Escape", "C-u"],
|
|
22
|
+
submit: ["Enter"],
|
|
23
|
+
jeda_ms: 1000,
|
|
24
|
+
},
|
|
25
|
+
{
|
|
26
|
+
suntik: "keys",
|
|
27
|
+
sebelum: ["Escape", "C-u"],
|
|
28
|
+
submit: ["Enter", "Enter"],
|
|
29
|
+
jeda_ms: 1000,
|
|
30
|
+
},
|
|
31
|
+
];
|
|
@@ -0,0 +1,78 @@
|
|
|
1
|
+
import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
|
|
2
|
+
import { homedir } from "node:os";
|
|
3
|
+
import { dirname, join } from "node:path";
|
|
4
|
+
const NAME = /^[a-z][a-z0-9-]{0,29}$/;
|
|
5
|
+
/** Lokasi registry; mengikuti `XDG_CONFIG_HOME`, jatuh ke `~/.config`. */
|
|
6
|
+
export function registryPath(env = process.env) {
|
|
7
|
+
const config = env.XDG_CONFIG_HOME || join(env.HOME || homedir(), ".config");
|
|
8
|
+
return join(config, "rempug", "registry.json");
|
|
9
|
+
}
|
|
10
|
+
function isAgent(value) {
|
|
11
|
+
if (typeof value !== "object" || value === null)
|
|
12
|
+
return false;
|
|
13
|
+
const a = value;
|
|
14
|
+
return (typeof a.name === "string" &&
|
|
15
|
+
typeof a.kind === "string" &&
|
|
16
|
+
typeof a.tmux === "string" &&
|
|
17
|
+
Array.isArray(a.capabilities) &&
|
|
18
|
+
a.capabilities.every((c) => typeof c === "string"));
|
|
19
|
+
}
|
|
20
|
+
/** Agent terdaftar; berkas yang belum ada dianggap kosong. */
|
|
21
|
+
export function readAgents(file) {
|
|
22
|
+
let raw;
|
|
23
|
+
try {
|
|
24
|
+
raw = readFileSync(file, "utf8");
|
|
25
|
+
}
|
|
26
|
+
catch (error) {
|
|
27
|
+
if (error.code === "ENOENT")
|
|
28
|
+
return [];
|
|
29
|
+
throw error;
|
|
30
|
+
}
|
|
31
|
+
try {
|
|
32
|
+
const data = JSON.parse(raw);
|
|
33
|
+
if (!Array.isArray(data.agents) || !data.agents.every(isAgent))
|
|
34
|
+
throw new Error("bentuk tidak dikenal");
|
|
35
|
+
return data.agents;
|
|
36
|
+
}
|
|
37
|
+
catch (error) {
|
|
38
|
+
throw new Error(`registry rusak: ${file}: ${error.message}`);
|
|
39
|
+
}
|
|
40
|
+
}
|
|
41
|
+
function writeAgents(file, agents) {
|
|
42
|
+
mkdirSync(dirname(file), { recursive: true });
|
|
43
|
+
// Tulis ke berkas sementara lalu ganti nama, supaya pembaca tidak pernah melihat berkas setengah jadi.
|
|
44
|
+
const temp = `${file}.${process.pid}.tmp`;
|
|
45
|
+
writeFileSync(temp, `${JSON.stringify({ agents }, null, 2)}\n`);
|
|
46
|
+
renameSync(temp, file);
|
|
47
|
+
}
|
|
48
|
+
export function registerAgent(file, agent) {
|
|
49
|
+
if (!NAME.test(agent.name))
|
|
50
|
+
throw new Error(`nama agent "${agent.name}" tidak valid: huruf kecil, angka, atau "-", diawali huruf, maksimal 30 karakter`);
|
|
51
|
+
const agents = readAgents(file);
|
|
52
|
+
if (agents.some((a) => a.name === agent.name))
|
|
53
|
+
throw new Error(`agent "${agent.name}" sudah terdaftar`);
|
|
54
|
+
const dipakai = agents.find((a) => a.tmux === agent.tmux);
|
|
55
|
+
if (dipakai)
|
|
56
|
+
throw new Error(`pane ${agent.tmux} sudah dipakai agent "${dipakai.name}"`);
|
|
57
|
+
writeAgents(file, [...agents, agent]);
|
|
58
|
+
}
|
|
59
|
+
/** Mengembalikan `true` bila agent ada dan terhapus. */
|
|
60
|
+
export function removeAgent(file, name) {
|
|
61
|
+
const agents = readAgents(file);
|
|
62
|
+
const sisa = agents.filter((a) => a.name !== name);
|
|
63
|
+
if (sisa.length === agents.length)
|
|
64
|
+
return false;
|
|
65
|
+
writeAgents(file, sisa);
|
|
66
|
+
return true;
|
|
67
|
+
}
|
|
68
|
+
/** Memperbarui bidang agent (mis. hasil probe); galat bila agent tidak ada. */
|
|
69
|
+
export function updateAgent(file, name, fields) {
|
|
70
|
+
const agents = readAgents(file);
|
|
71
|
+
const index = agents.findIndex((a) => a.name === name);
|
|
72
|
+
if (index < 0)
|
|
73
|
+
throw new Error(`agent "${name}" tidak terdaftar`);
|
|
74
|
+
const baru = { ...agents[index], ...fields };
|
|
75
|
+
agents[index] = baru;
|
|
76
|
+
writeAgents(file, agents);
|
|
77
|
+
return baru;
|
|
78
|
+
}
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import { RempugError } from "./errors.js";
|
|
2
|
+
/** Status tempat balasan agent masih diterima. */
|
|
3
|
+
const BISA_DIBALAS = [
|
|
4
|
+
"berjalan",
|
|
5
|
+
"menunggu-klarifikasi",
|
|
6
|
+
"macet",
|
|
7
|
+
];
|
|
8
|
+
const RINGKASAN_BARIS = 12;
|
|
9
|
+
const RINGKASAN_LEBAR = 200;
|
|
10
|
+
/** Baris tidak kosong pertama, dibatasi jumlah dan lebarnya; detail lengkap tetap tersimpan terpisah. */
|
|
11
|
+
function ringkas(teks) {
|
|
12
|
+
return teks
|
|
13
|
+
.split("\n")
|
|
14
|
+
.map((l) => l.trim())
|
|
15
|
+
.filter(Boolean)
|
|
16
|
+
.slice(0, RINGKASAN_BARIS)
|
|
17
|
+
.map((l) => l.length > RINGKASAN_LEBAR ? `${l.slice(0, RINGKASAN_LEBAR - 1)}…` : l)
|
|
18
|
+
.join("\n");
|
|
19
|
+
}
|
|
20
|
+
/** Menyimpan balasan agent dan memulai verifikasi (atau menandai gagal bila `--gagal`). */
|
|
21
|
+
export function reply(ledger, id, teks, options) {
|
|
22
|
+
const task = ledger.getTask(id);
|
|
23
|
+
if (!task)
|
|
24
|
+
throw new RempugError(`tugas T${id} tidak ada`);
|
|
25
|
+
if (!BISA_DIBALAS.includes(task.status))
|
|
26
|
+
throw new RempugError(`tugas T${id} berstatus ${task.status}; balasan ditolak`);
|
|
27
|
+
const ringkasan = ringkas(teks);
|
|
28
|
+
ledger.saveReply(id, ringkasan, teks);
|
|
29
|
+
if (options.gagal) {
|
|
30
|
+
ledger.setStatus(id, "gagal");
|
|
31
|
+
const alasan = (ringkasan.split("\n")[0] ?? "").slice(0, 120);
|
|
32
|
+
ledger.addEvent(id, "gagal", `T${id} ${task.agent} ✗ gagal: ${alasan}`);
|
|
33
|
+
return { status: "gagal" };
|
|
34
|
+
}
|
|
35
|
+
ledger.setStatus(id, "memverifikasi");
|
|
36
|
+
options.spawnVerify(id);
|
|
37
|
+
return { status: "memverifikasi" };
|
|
38
|
+
}
|
|
@@ -0,0 +1,96 @@
|
|
|
1
|
+
const MAKS_PER_KELOMPOK = 10;
|
|
2
|
+
function hasilVerifikasi(task) {
|
|
3
|
+
return task.verify ? JSON.parse(task.verify) : undefined;
|
|
4
|
+
}
|
|
5
|
+
const indent = (teks) => teks
|
|
6
|
+
.split("\n")
|
|
7
|
+
.map((l) => ` ${l}`)
|
|
8
|
+
.join("\n");
|
|
9
|
+
/** Satu baris per tugas: hasil verifikasi bila ada, selain itu status singkat. */
|
|
10
|
+
export function barisLog(task) {
|
|
11
|
+
const hasil = hasilVerifikasi(task);
|
|
12
|
+
if (hasil)
|
|
13
|
+
return hasil.linha;
|
|
14
|
+
const kepala = `T${task.id} ${task.agent}`;
|
|
15
|
+
if (task.status === "gagal") {
|
|
16
|
+
const alasan = (task.replySummary ?? "").split("\n")[0] ?? "";
|
|
17
|
+
return alasan ? `${kepala} ✗ gagal: ${alasan}` : `${kepala} ✗ gagal`;
|
|
18
|
+
}
|
|
19
|
+
return task.flag
|
|
20
|
+
? `${kepala} ${task.status} (${task.flag})`
|
|
21
|
+
: `${kepala} ${task.status}`;
|
|
22
|
+
}
|
|
23
|
+
/** Ringkasan satu tugas; `penuh` menambah brief, balasan lengkap, daftar perubahan, dan ekor cek yang gagal. */
|
|
24
|
+
export function formatShow(task, penuh) {
|
|
25
|
+
const bagian = [
|
|
26
|
+
`T${task.id} ${task.agent} ${task.status} (${task.mode})`,
|
|
27
|
+
barisLog(task),
|
|
28
|
+
];
|
|
29
|
+
if (task.replySummary)
|
|
30
|
+
bagian.push(`ringkasan:\n${indent(task.replySummary)}`);
|
|
31
|
+
if (!penuh)
|
|
32
|
+
return bagian.join("\n");
|
|
33
|
+
bagian.push(`brief:\n${indent(task.brief.trim())}`);
|
|
34
|
+
if (task.replyDetail)
|
|
35
|
+
bagian.push(`balasan lengkap:\n${indent(task.replyDetail)}`);
|
|
36
|
+
const hasil = hasilVerifikasi(task);
|
|
37
|
+
if (hasil?.perubahan.length)
|
|
38
|
+
bagian.push(`perubahan:\n${indent(hasil.perubahan.map((f) => `${f.status} ${f.path} +${f.plus}/−${f.minus}${f.biner ? " (biner)" : ""}`).join("\n"))}`);
|
|
39
|
+
for (const cek of hasil?.cek ?? [])
|
|
40
|
+
if (!cek.ok)
|
|
41
|
+
bagian.push(`cek gagal ${cek.label}:\n${indent(cek.ekor)}`);
|
|
42
|
+
return bagian.join("\n");
|
|
43
|
+
}
|
|
44
|
+
const SELESAI = ["selesai"];
|
|
45
|
+
const GAGAL = ["gagal", "gagal-paham", "pelanggaran", "bentrok"];
|
|
46
|
+
const BLOCKER_STATUS = [
|
|
47
|
+
"macet",
|
|
48
|
+
"menunggu-klarifikasi",
|
|
49
|
+
"pelanggaran",
|
|
50
|
+
"gagal-paham",
|
|
51
|
+
];
|
|
52
|
+
const BLOCKER_FLAG = ["menunggu-izin", "bertanya", "diterima-tanpa-ack"];
|
|
53
|
+
function kelompok(tasks) {
|
|
54
|
+
return {
|
|
55
|
+
selesai: tasks.filter((t) => SELESAI.includes(t.status)),
|
|
56
|
+
berjalan: tasks.filter((t) => t.status === "berjalan" ||
|
|
57
|
+
t.status === "memverifikasi" ||
|
|
58
|
+
t.status === "antri"),
|
|
59
|
+
gagal: tasks.filter((t) => GAGAL.includes(t.status)),
|
|
60
|
+
blocker: tasks.filter((t) => BLOCKER_STATUS.includes(t.status) ||
|
|
61
|
+
(t.status === "berjalan" &&
|
|
62
|
+
t.flag !== undefined &&
|
|
63
|
+
BLOCKER_FLAG.includes(t.flag))),
|
|
64
|
+
};
|
|
65
|
+
}
|
|
66
|
+
/** Laporan teks ringkas per repo: selesai, berjalan, gagal, dan blocker; daftar panjang dipotong. */
|
|
67
|
+
export function formatLaporan(repo, tasks) {
|
|
68
|
+
if (tasks.length === 0)
|
|
69
|
+
return `laporan rempug ${repo}\nbelum ada tugas`;
|
|
70
|
+
const k = kelompok(tasks);
|
|
71
|
+
const bagian = [`laporan rempug ${repo}`];
|
|
72
|
+
for (const [nama, daftar] of Object.entries(k)) {
|
|
73
|
+
if (daftar.length === 0)
|
|
74
|
+
continue;
|
|
75
|
+
const baris = daftar
|
|
76
|
+
.slice(0, MAKS_PER_KELOMPOK)
|
|
77
|
+
.map((t) => ` ${barisLog(t)}`);
|
|
78
|
+
if (daftar.length > MAKS_PER_KELOMPOK)
|
|
79
|
+
baris.push(` +${daftar.length - MAKS_PER_KELOMPOK} lagi`);
|
|
80
|
+
bagian.push(`${nama} (${daftar.length})\n${baris.join("\n")}`);
|
|
81
|
+
}
|
|
82
|
+
return bagian.join("\n");
|
|
83
|
+
}
|
|
84
|
+
export function formatLaporanMd(repo, tasks) {
|
|
85
|
+
const k = kelompok(tasks);
|
|
86
|
+
const bagian = [`# Laporan rempug\n\nRepo: \`${repo}\``];
|
|
87
|
+
for (const [nama, daftar] of Object.entries(k)) {
|
|
88
|
+
if (daftar.length === 0)
|
|
89
|
+
continue;
|
|
90
|
+
const judul = nama[0]?.toUpperCase() + nama.slice(1);
|
|
91
|
+
bagian.push(`## ${judul} (${daftar.length})\n\n${daftar.map((t) => `- ${barisLog(t)}`).join("\n")}`);
|
|
92
|
+
}
|
|
93
|
+
if (tasks.length === 0)
|
|
94
|
+
bagian.push("Belum ada tugas.");
|
|
95
|
+
return `${bagian.join("\n\n")}\n`;
|
|
96
|
+
}
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
import { listPanes } from "./tmux.js";
|
|
2
|
+
/** Perintah yang dikenali sebagai agent CLI; juga menjadi `jenis`. */
|
|
3
|
+
const KNOWN_KINDS = new Set(["codex", "agy", "claude", "gemini", "opencode"]);
|
|
4
|
+
/** Perintah yang bukan agent: editor, shell, dan pager. */
|
|
5
|
+
const EXCLUDED = new Set([
|
|
6
|
+
"nvim",
|
|
7
|
+
"vim",
|
|
8
|
+
"vi",
|
|
9
|
+
"bash",
|
|
10
|
+
"zsh",
|
|
11
|
+
"sh",
|
|
12
|
+
"fish",
|
|
13
|
+
"dash",
|
|
14
|
+
"less",
|
|
15
|
+
"htop",
|
|
16
|
+
"top",
|
|
17
|
+
"man",
|
|
18
|
+
"tmux",
|
|
19
|
+
]);
|
|
20
|
+
function score(pane, repo) {
|
|
21
|
+
let skor = KNOWN_KINDS.has(pane.command) ? 3 : 0;
|
|
22
|
+
if (pane.path === repo)
|
|
23
|
+
skor += 2;
|
|
24
|
+
else if (pane.path.startsWith(`${repo}/`))
|
|
25
|
+
skor += 1;
|
|
26
|
+
return skor;
|
|
27
|
+
}
|
|
28
|
+
/** Memberi skor keyakinan tiap pane dan membuang pane orkestrator sendiri serta pane non-agent. */
|
|
29
|
+
export function scorePanes(panes, repo, selfPane) {
|
|
30
|
+
return panes
|
|
31
|
+
.filter((p) => p.paneId !== selfPane && !EXCLUDED.has(p.command))
|
|
32
|
+
.map((p) => {
|
|
33
|
+
const skor = score(p, repo);
|
|
34
|
+
return {
|
|
35
|
+
target: p.target,
|
|
36
|
+
sesi: p.session,
|
|
37
|
+
perintah: p.command,
|
|
38
|
+
direktori: p.path,
|
|
39
|
+
jenis: KNOWN_KINDS.has(p.command) ? p.command : "tidak-diketahui",
|
|
40
|
+
skor,
|
|
41
|
+
keyakinan: (skor >= 3
|
|
42
|
+
? "tinggi"
|
|
43
|
+
: skor >= 1
|
|
44
|
+
? "sedang"
|
|
45
|
+
: "rendah"),
|
|
46
|
+
};
|
|
47
|
+
})
|
|
48
|
+
.sort((a, b) => b.skor - a.skor || a.target.localeCompare(b.target));
|
|
49
|
+
}
|
|
50
|
+
export function scan(repo, options = {}) {
|
|
51
|
+
// ID pane hanya unik dalam satu server, jadi `$TMUX_PANE` tidak berarti untuk socket lain.
|
|
52
|
+
const selfPane = options.selfPane ??
|
|
53
|
+
(options.tmux?.socket ? undefined : process.env.TMUX_PANE);
|
|
54
|
+
return {
|
|
55
|
+
repo,
|
|
56
|
+
kandidat: scorePanes(listPanes(options.tmux), repo, selfPane),
|
|
57
|
+
};
|
|
58
|
+
}
|