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,103 @@
|
|
|
1
|
+
const WILDCARD = /[*?[]/;
|
|
2
|
+
/**
|
|
3
|
+
* Memecah pola menjadi segmen. Path tanpa wildcard dianggap sebagai dirinya sendiri
|
|
4
|
+
* beserta isinya (`src/a` ≡ `src/a/**`), karena tanpa melihat disk tidak diketahui
|
|
5
|
+
* apakah ia berkas atau direktori. Akibatnya pengecekan konservatif: lebih baik
|
|
6
|
+
* menolak tugas yang sebenarnya aman daripada membiarkan dua agent menimpa file yang sama.
|
|
7
|
+
*/
|
|
8
|
+
function segments(pattern) {
|
|
9
|
+
const clean = pattern
|
|
10
|
+
.trim()
|
|
11
|
+
.replace(/^(\.\/)+/, "")
|
|
12
|
+
.replace(/\/+/g, "/")
|
|
13
|
+
.replace(/\/$/, "");
|
|
14
|
+
if (clean === "" || clean === ".")
|
|
15
|
+
return ["**"];
|
|
16
|
+
const parts = clean.split("/").filter((s) => s !== ".");
|
|
17
|
+
return parts.some((s) => WILDCARD.test(s)) ? parts : [...parts, "**"];
|
|
18
|
+
}
|
|
19
|
+
function segmentsMatch(a, b) {
|
|
20
|
+
if (a === b)
|
|
21
|
+
return true;
|
|
22
|
+
const aWild = WILDCARD.test(a);
|
|
23
|
+
const bWild = WILDCARD.test(b);
|
|
24
|
+
if (!aWild && !bWild)
|
|
25
|
+
return false;
|
|
26
|
+
if (aWild && bWild)
|
|
27
|
+
return true;
|
|
28
|
+
const [glob, literal] = aWild ? [a, b] : [b, a];
|
|
29
|
+
if (glob.includes("["))
|
|
30
|
+
return true;
|
|
31
|
+
const regex = glob
|
|
32
|
+
.replace(/[.+^${}()|\]\\]/g, "\\$&")
|
|
33
|
+
.replace(/\*/g, "[^/]*")
|
|
34
|
+
.replace(/\?/g, "[^/]");
|
|
35
|
+
return new RegExp(`^${regex}$`).test(literal);
|
|
36
|
+
}
|
|
37
|
+
function overlap(a, b) {
|
|
38
|
+
if (a.length === 0)
|
|
39
|
+
return b.every((s) => s === "**");
|
|
40
|
+
if (b.length === 0)
|
|
41
|
+
return a.every((s) => s === "**");
|
|
42
|
+
const [x, ...xs] = a;
|
|
43
|
+
const [y, ...ys] = b;
|
|
44
|
+
if (x === "**")
|
|
45
|
+
return overlap(xs, b) || overlap(a, ys);
|
|
46
|
+
if (y === "**")
|
|
47
|
+
return overlap(a, ys) || overlap(xs, b);
|
|
48
|
+
return segmentsMatch(x, y) && overlap(xs, ys);
|
|
49
|
+
}
|
|
50
|
+
/** Apakah ada satu pasang pola dari kedua daftar yang mungkin mencocokkan path yang sama. */
|
|
51
|
+
export function scopesOverlap(a, b) {
|
|
52
|
+
return a.some((p) => b.some((q) => overlap(segments(p), segments(q))));
|
|
53
|
+
}
|
|
54
|
+
/**
|
|
55
|
+
* Tugas `edit` aktif yang cakupannya beririsan dengan tugas baru. Tugas `baca`
|
|
56
|
+
* dan `browser` tidak mengklaim cakupan, jadi tidak pernah bentrok.
|
|
57
|
+
*/
|
|
58
|
+
export function claimConflicts(ledger, repo, task) {
|
|
59
|
+
if (task.mode !== "edit" || !task.scope)
|
|
60
|
+
return [];
|
|
61
|
+
const conflicts = [];
|
|
62
|
+
for (const aktif of ledger.activeEditTasks(repo)) {
|
|
63
|
+
for (const pola of task.scope) {
|
|
64
|
+
const denganPola = aktif.scope?.find((q) => scopesOverlap([pola], [q]));
|
|
65
|
+
if (denganPola !== undefined) {
|
|
66
|
+
conflicts.push({
|
|
67
|
+
taskId: aktif.id,
|
|
68
|
+
agent: aktif.agent,
|
|
69
|
+
pola,
|
|
70
|
+
denganPola,
|
|
71
|
+
});
|
|
72
|
+
break;
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
}
|
|
76
|
+
return conflicts;
|
|
77
|
+
}
|
|
78
|
+
export function formatConflict(c) {
|
|
79
|
+
return `bentrok dengan T${c.taskId} (${c.agent}): ${c.pola} beririsan dengan ${c.denganPola}`;
|
|
80
|
+
}
|
|
81
|
+
function matchLiteral(pattern, literal) {
|
|
82
|
+
if (pattern.length === 0)
|
|
83
|
+
return literal.length === 0;
|
|
84
|
+
const [p, ...rest] = pattern;
|
|
85
|
+
if (p === "**")
|
|
86
|
+
return (matchLiteral(rest, literal) ||
|
|
87
|
+
(literal.length > 0 && matchLiteral(pattern, literal.slice(1))));
|
|
88
|
+
if (literal.length === 0)
|
|
89
|
+
return false;
|
|
90
|
+
return (segmentsMatch(p, literal[0]) &&
|
|
91
|
+
matchLiteral(rest, literal.slice(1)));
|
|
92
|
+
}
|
|
93
|
+
/** Apakah `path` termasuk dalam salah satu pola cakupan (path tanpa wildcard mencakup isinya). */
|
|
94
|
+
export function covers(patterns, path) {
|
|
95
|
+
const literal = path
|
|
96
|
+
.trim()
|
|
97
|
+
.replace(/^(\.\/)+/, "")
|
|
98
|
+
.replace(/\/+/g, "/")
|
|
99
|
+
.replace(/\/$/, "")
|
|
100
|
+
.split("/")
|
|
101
|
+
.filter((s) => s !== "" && s !== ".");
|
|
102
|
+
return patterns.some((p) => matchLiteral(segments(p), literal));
|
|
103
|
+
}
|
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
const POLA_IZIN = [
|
|
3
|
+
/\b(allow|approve|permit|authorize)\b[^\n]{0,80}\?/i,
|
|
4
|
+
/\(y\/n\)/i,
|
|
5
|
+
/\[y\/n\]/i,
|
|
6
|
+
/press enter to (continue|confirm|approve)/i,
|
|
7
|
+
/do you want to (proceed|run|allow|make this edit|create)/i,
|
|
8
|
+
/izinkan/i,
|
|
9
|
+
// Dialog yang muncul saat agent pertama kali dibuka di sebuah folder.
|
|
10
|
+
/do you trust|trust (this|the|these) (folder|project|contents|workspace|directory)/i,
|
|
11
|
+
];
|
|
12
|
+
const POLA_LIMIT = [
|
|
13
|
+
/rate limit|usage limit|quota (exceeded|reached)|limit (reached|exceeded)/i,
|
|
14
|
+
/hit your (usage )?limit|too many requests|\b429\b|credit balance|out of credits/i,
|
|
15
|
+
// Galat autentikasi: agent tidak bisa memanggil modelnya, sama buntunya dengan kehabisan kuota.
|
|
16
|
+
/token refresh failed|\b401\b|unauthorized|authentication (failed|error)|invalid api key|not logged in|log ?in again|login required/i,
|
|
17
|
+
];
|
|
18
|
+
/** Jumlah baris terakhir yang dianggap "saat ini"; yang lebih atas adalah riwayat. */
|
|
19
|
+
const BARIS_AKHIR = 8;
|
|
20
|
+
/** Baris di atas kursor yang masih dianggap bagian kotak input (input yang terbungkus beberapa baris). */
|
|
21
|
+
const BARIS_INPUT = 2;
|
|
22
|
+
const squash = (teks) => teks.replace(/\s+/g, "");
|
|
23
|
+
const tidakKosong = (baris) => baris.map((b) => b.trimEnd()).filter((b) => b.trim() !== "");
|
|
24
|
+
const bersih = (baris) => baris.replace(/^[\s│┃|]+|[\s│┃|]+$/g, "");
|
|
25
|
+
/** Mengabaikan spinner, angka (timer), dan spasi, sehingga hanya perubahan teks yang dihitung sebagai kemajuan. */
|
|
26
|
+
export function normalisasi(teks) {
|
|
27
|
+
return teks
|
|
28
|
+
.replace(/[⠀-⣿✻✶✳✢·●○◐◓◑◒⏺|/\\-]/g, "")
|
|
29
|
+
.replace(/\d+/g, "")
|
|
30
|
+
.replace(/\s+/g, " ")
|
|
31
|
+
.trim();
|
|
32
|
+
}
|
|
33
|
+
export function hashLayar(teks) {
|
|
34
|
+
return createHash("sha1").update(normalisasi(teks)).digest("hex");
|
|
35
|
+
}
|
|
36
|
+
/** Apakah `token` (mis. `rempug brief T12`) ada di layar; spasi diabaikan karena baris bisa terbungkus. */
|
|
37
|
+
export function tokenDiLayar(baris, token) {
|
|
38
|
+
return squash(baris.join("")).includes(squash(token));
|
|
39
|
+
}
|
|
40
|
+
/** Pertanyaan terakhir agent dalam beberapa baris terakhir, tanpa garis kotak; kosong bila tidak ada. */
|
|
41
|
+
export function pertanyaan(baris) {
|
|
42
|
+
const kandidat = tidakKosong(baris)
|
|
43
|
+
.slice(-BARIS_AKHIR)
|
|
44
|
+
.map(bersih)
|
|
45
|
+
.filter((b) => b.endsWith("?"));
|
|
46
|
+
const terakhir = kandidat.at(-1);
|
|
47
|
+
if (terakhir === undefined)
|
|
48
|
+
return undefined;
|
|
49
|
+
return terakhir.length > 200 ? `${terakhir.slice(0, 199)}…` : terakhir;
|
|
50
|
+
}
|
|
51
|
+
/** Teks tertahan di kotak input: token ada di baris kursor atau beberapa baris di atasnya. */
|
|
52
|
+
function tertahan(baris, kursorY, token) {
|
|
53
|
+
if (kursorY === undefined)
|
|
54
|
+
return tokenDiLayar(tidakKosong(baris).slice(-3), token);
|
|
55
|
+
return tokenDiLayar(baris.slice(Math.max(0, kursorY - BARIS_INPUT), kursorY + 1), token);
|
|
56
|
+
}
|
|
57
|
+
/** Menggolongkan layar secara mekanis; tidak memakai token model sama sekali. */
|
|
58
|
+
export function klasifikasi(masuk) {
|
|
59
|
+
if (masuk.berubah)
|
|
60
|
+
return "bekerja";
|
|
61
|
+
const akhir = tidakKosong(masuk.baris).slice(-BARIS_AKHIR).join("\n");
|
|
62
|
+
const tambahan = (pola) => (pola ?? []).map((p) => new RegExp(p, "i"));
|
|
63
|
+
if ([...POLA_LIMIT, ...tambahan(masuk.polaLimit)].some((p) => p.test(akhir)))
|
|
64
|
+
return "error";
|
|
65
|
+
if ([...POLA_IZIN, ...tambahan(masuk.polaIzin)].some((p) => p.test(akhir)))
|
|
66
|
+
return "menunggu-izin";
|
|
67
|
+
const token = masuk.token;
|
|
68
|
+
if (token && tertahan(masuk.baris, masuk.kursorY, token))
|
|
69
|
+
return "tertahan";
|
|
70
|
+
const tanpaPointer = token
|
|
71
|
+
? masuk.baris.filter((b) => !squash(b).includes(squash(token)))
|
|
72
|
+
: masuk.baris;
|
|
73
|
+
return pertanyaan(tanpaPointer) ? "bertanya" : "siap";
|
|
74
|
+
}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
/** Memecah teks berlabel `NAMA: isi` menjadi bagian; isi berlanjut sampai label berikutnya. */
|
|
2
|
+
export function parseSections(text, labels) {
|
|
3
|
+
const label = new RegExp(`^(${labels.join("|")}):[ \\t]*(.*)$`);
|
|
4
|
+
const found = new Map();
|
|
5
|
+
const errors = [];
|
|
6
|
+
let current;
|
|
7
|
+
for (const line of text.replace(/\r\n/g, "\n").split("\n")) {
|
|
8
|
+
const match = label.exec(line);
|
|
9
|
+
if (match) {
|
|
10
|
+
current = match[1];
|
|
11
|
+
if (found.has(current))
|
|
12
|
+
errors.push(`bagian ${current} muncul dua kali`);
|
|
13
|
+
else
|
|
14
|
+
found.set(current, [match[2] ?? ""]);
|
|
15
|
+
}
|
|
16
|
+
else if (current)
|
|
17
|
+
found.get(current)?.push(line);
|
|
18
|
+
else if (line.trim())
|
|
19
|
+
errors.push(`ada teks sebelum label pertama: "${line.trim()}"`);
|
|
20
|
+
}
|
|
21
|
+
return {
|
|
22
|
+
body: new Map([...found].map(([k, lines]) => [k, lines.join("\n").trim()])),
|
|
23
|
+
errors,
|
|
24
|
+
};
|
|
25
|
+
}
|
|
@@ -0,0 +1,161 @@
|
|
|
1
|
+
import { agentRows, requireAvailable } from "./agents.js";
|
|
2
|
+
import { parseBrief } from "./brief.js";
|
|
3
|
+
import { RempugError, UsageError } from "./errors.js";
|
|
4
|
+
import { gitInfo } from "./git.js";
|
|
5
|
+
import { PROFIL_BAWAAN } from "./profile.js";
|
|
6
|
+
import { claimConflicts, formatConflict } from "./scope.js";
|
|
7
|
+
/** Nama konsumen kejadian milik orkestrator. */
|
|
8
|
+
export const KONSUMEN = "orkestrator";
|
|
9
|
+
/** `watch` dianggap hidup bila terlihat dalam rentang ini (detik). */
|
|
10
|
+
const WATCH_HIDUP_DETIK = 10;
|
|
11
|
+
/** Status tugas yang tidak akan pernah selesai; tugas yang menunggunya dibatalkan. */
|
|
12
|
+
const TIDAK_SELESAI = [
|
|
13
|
+
"gagal",
|
|
14
|
+
"gagal-paham",
|
|
15
|
+
"pelanggaran",
|
|
16
|
+
"macet",
|
|
17
|
+
"bentrok",
|
|
18
|
+
];
|
|
19
|
+
/** Satu baris yang diketik ke TUI agent; seluruh isi tugas dibaca lewat `rempug brief`. */
|
|
20
|
+
export function pointer(id) {
|
|
21
|
+
return `Tugas T${id}: jalankan \`rempug brief T${id}\`, kerjakan persis isinya, lalu balas dengan \`rempug reply T${id}\` (isi lewat stdin). Dilarang git commit, push, reset, checkout, stash.`;
|
|
22
|
+
}
|
|
23
|
+
function peringatanWatch(ledger) {
|
|
24
|
+
const seen = ledger.getConsumer(KONSUMEN)?.lastSeen;
|
|
25
|
+
if (seen !== undefined && ledger.now() - seen <= WATCH_HIDUP_DETIK)
|
|
26
|
+
return undefined;
|
|
27
|
+
return "peringatan: `rempug watch` belum aktif; pasang lewat Monitor (timeout maksimum) sebelum menunggu hasil.";
|
|
28
|
+
}
|
|
29
|
+
async function deliver(deps, task, row) {
|
|
30
|
+
const { ledger } = deps;
|
|
31
|
+
try {
|
|
32
|
+
await deps.siapkan?.(task);
|
|
33
|
+
ledger.setStatus(task.id, "berjalan");
|
|
34
|
+
ledger.patch(task.id, { scrHash: null, scrSince: ledger.now() });
|
|
35
|
+
await deps.transport.kirim(row.tmux, pointer(task.id), row.kirim ?? PROFIL_BAWAAN);
|
|
36
|
+
}
|
|
37
|
+
catch (error) {
|
|
38
|
+
const pesan = error.message;
|
|
39
|
+
ledger.setStatus(task.id, "gagal");
|
|
40
|
+
ledger.addEvent(task.id, "gagal", `T${task.id} ${task.agent} ✗ pengiriman gagal: ${pesan}`);
|
|
41
|
+
throw new RempugError(`pengiriman T${task.id} gagal: ${pesan}`);
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
/** Membuat tugas, lalu mengirimnya ke agent atau mengantrekannya; kembali segera tanpa menunggu agent. */
|
|
45
|
+
export async function sendTask(deps, input) {
|
|
46
|
+
const { ledger, repo } = deps;
|
|
47
|
+
const parsed = parseBrief(input.brief);
|
|
48
|
+
if (!parsed.ok)
|
|
49
|
+
throw new UsageError(`brief tidak lengkap:\n${parsed.errors.map((e) => `- ${e}`).join("\n")}`);
|
|
50
|
+
const { cakupan } = parsed.brief;
|
|
51
|
+
const scope = cakupan.mode === "edit" ? cakupan.paths : undefined;
|
|
52
|
+
const row = requireAvailable(agentRows(deps.registryFile, ledger, deps.tmux), input.agent);
|
|
53
|
+
let menungguTugas = false;
|
|
54
|
+
if (input.afterId !== undefined) {
|
|
55
|
+
const sebelum = ledger.getTask(input.afterId);
|
|
56
|
+
if (!sebelum || sebelum.repo !== repo)
|
|
57
|
+
throw new UsageError(`--after T${input.afterId}: tugas tidak ada di repo ini`);
|
|
58
|
+
if (TIDAK_SELESAI.includes(sebelum.status))
|
|
59
|
+
throw new UsageError(`--after T${sebelum.id}: tugas itu sudah ${sebelum.status}`);
|
|
60
|
+
menungguTugas = sebelum.status !== "selesai";
|
|
61
|
+
}
|
|
62
|
+
const antri = input.queue === true || input.afterId !== undefined;
|
|
63
|
+
if (row.status === "sibuk" && !antri)
|
|
64
|
+
throw new RempugError(`agent "${row.name}" sibuk (T${row.tugas}); pakai --queue untuk mengantre`);
|
|
65
|
+
const menunggu = menungguTugas || (row.status === "sibuk" && antri);
|
|
66
|
+
// Bentrok cakupan dicek saat benar-benar akan dikirim; tugas antrean dicek ulang oleh pump.
|
|
67
|
+
if (!menunggu) {
|
|
68
|
+
const konflik = claimConflicts(ledger, repo, { mode: cakupan.mode, scope });
|
|
69
|
+
if (konflik.length > 0)
|
|
70
|
+
throw new RempugError(konflik.map(formatConflict).join("\n"));
|
|
71
|
+
}
|
|
72
|
+
const git = gitInfo(repo);
|
|
73
|
+
const id = ledger.createTask({
|
|
74
|
+
repo,
|
|
75
|
+
agent: row.name,
|
|
76
|
+
mode: cakupan.mode,
|
|
77
|
+
scope,
|
|
78
|
+
brief: input.brief,
|
|
79
|
+
afterId: input.afterId,
|
|
80
|
+
headSha: git.head,
|
|
81
|
+
branch: git.branch,
|
|
82
|
+
porcelain: git.porcelain,
|
|
83
|
+
teliti: input.teliti,
|
|
84
|
+
centang: input.centang,
|
|
85
|
+
});
|
|
86
|
+
// Kursor awal = kejadian terakhir saat ini, supaya konsumen baru hanya menerima kejadian sesudah tugas ini.
|
|
87
|
+
ledger.ensureConsumer(KONSUMEN, ledger.maxEventId(repo));
|
|
88
|
+
const peringatan = peringatanWatch(ledger);
|
|
89
|
+
if (menunggu)
|
|
90
|
+
return { id, status: "antri", peringatan };
|
|
91
|
+
await deliver(deps, ledger.getTask(id), row);
|
|
92
|
+
return { id, status: "berjalan", peringatan };
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* Mengirim tugas antrean yang sudah boleh jalan (agent bebas, tugas `--after` selesai,
|
|
96
|
+
* tidak bentrok). Mengembalikan ID tugas yang dikirim.
|
|
97
|
+
*/
|
|
98
|
+
export async function pump(deps) {
|
|
99
|
+
const { ledger, repo } = deps;
|
|
100
|
+
const terkirim = [];
|
|
101
|
+
for (const task of ledger.tasksWhere(repo, ["antri"])) {
|
|
102
|
+
const batal = (alasan) => {
|
|
103
|
+
ledger.setStatus(task.id, "gagal");
|
|
104
|
+
ledger.addEvent(task.id, "dibatalkan", `T${task.id} ${task.agent} dibatalkan: ${alasan}`);
|
|
105
|
+
};
|
|
106
|
+
if (task.afterId !== undefined) {
|
|
107
|
+
const sebelum = ledger.getTask(task.afterId);
|
|
108
|
+
if (sebelum && TIDAK_SELESAI.includes(sebelum.status)) {
|
|
109
|
+
batal(`T${sebelum.id} ${sebelum.status}`);
|
|
110
|
+
continue;
|
|
111
|
+
}
|
|
112
|
+
if (sebelum && sebelum.status !== "selesai")
|
|
113
|
+
continue;
|
|
114
|
+
}
|
|
115
|
+
const row = agentRows(deps.registryFile, ledger, deps.tmux).find((r) => r.name === task.agent);
|
|
116
|
+
if (!row || row.status === "hilang") {
|
|
117
|
+
batal(`agent ${task.agent} hilang`);
|
|
118
|
+
continue;
|
|
119
|
+
}
|
|
120
|
+
if (row.status !== "siap")
|
|
121
|
+
continue;
|
|
122
|
+
if (claimConflicts(ledger, repo, { mode: task.mode, scope: task.scope })
|
|
123
|
+
.length > 0)
|
|
124
|
+
continue;
|
|
125
|
+
await deliver(deps, task, row);
|
|
126
|
+
terkirim.push(task.id);
|
|
127
|
+
}
|
|
128
|
+
return terkirim;
|
|
129
|
+
}
|
|
130
|
+
/** Teks tugas untuk agent; membaca ini menandai brief sudah diterima (ack). */
|
|
131
|
+
export function readBrief(ledger, id) {
|
|
132
|
+
const task = ledger.getTask(id);
|
|
133
|
+
if (!task)
|
|
134
|
+
throw new RempugError(`tugas T${id} tidak ada`);
|
|
135
|
+
ledger.markAcked(id);
|
|
136
|
+
const edit = task.mode === "edit";
|
|
137
|
+
const langkah = [
|
|
138
|
+
...(edit
|
|
139
|
+
? [
|
|
140
|
+
`Sebelum mengubah file, jalankan \`rempug paham T${id}\` (isi lewat stdin) dengan bagian berlabel:
|
|
141
|
+
CAKUPAN: <sama dengan brief>
|
|
142
|
+
CEK: <sama dengan brief>
|
|
143
|
+
RENCANA: maksimal 3 butir
|
|
144
|
+
ASUMSI: (tulis - bila tidak ada)
|
|
145
|
+
PERTANYAAN: (tulis - bila tidak ada)
|
|
146
|
+
Bila hasilnya "LANJUT", mulai bekerja. Bila "MENUNGGU", jalankan \`rempug tunggu T${id}\` dan ulangi sampai "LANJUT".`,
|
|
147
|
+
]
|
|
148
|
+
: []),
|
|
149
|
+
"Kerjakan langkah-langkah di atas persis sesuai isinya.",
|
|
150
|
+
`Setelah selesai, balas dengan \`rempug reply T${id}\` (isi lewat stdin): HASIL, BUKTI, BLOCKER. Bila tidak bisa menyelesaikan: \`rempug reply T${id} --gagal\`.`,
|
|
151
|
+
];
|
|
152
|
+
return [
|
|
153
|
+
`TUGAS T${id} (${task.mode}) untuk repo ${task.repo}`,
|
|
154
|
+
"ATURAN: kerjakan PERSIS isi tugas. Dilarang git commit, push, reset, checkout, stash. Jangan menyentuh file di luar CAKUPAN.",
|
|
155
|
+
"",
|
|
156
|
+
task.brief.trim(),
|
|
157
|
+
"",
|
|
158
|
+
"PROTOKOL:",
|
|
159
|
+
...langkah.map((l, i) => `${i + 1}. ${l}`),
|
|
160
|
+
].join("\n");
|
|
161
|
+
}
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
import { PROFIL_BAWAAN } from "./profile.js";
|
|
2
|
+
import { readAgents, updateAgent } from "./registry.js";
|
|
3
|
+
import { hashLayar, klasifikasi, pertanyaan } from "./screen.js";
|
|
4
|
+
import { pointer } from "./send.js";
|
|
5
|
+
import { listPanes } from "./tmux.js";
|
|
6
|
+
export const TICK_BAWAAN = {
|
|
7
|
+
ackDetik: 45,
|
|
8
|
+
diamDetik: 10,
|
|
9
|
+
macetDetik: 120,
|
|
10
|
+
maksUpaya: 3,
|
|
11
|
+
};
|
|
12
|
+
/**
|
|
13
|
+
* Satu putaran pemantauan layar untuk tugas yang sedang berjalan: mengulang pengiriman yang
|
|
14
|
+
* tertahan, melaporkan pertanyaan, izin, limit, dan agent yang diam. Seluruhnya mekanis;
|
|
15
|
+
* orkestrator baru terlibat saat sebuah kejadian dikeluarkan. Mengembalikan baris kejadian baru.
|
|
16
|
+
*/
|
|
17
|
+
export async function tick(deps) {
|
|
18
|
+
const o = { ...TICK_BAWAAN, ...deps.opsi };
|
|
19
|
+
const { ledger, transport } = deps;
|
|
20
|
+
const keluar = [];
|
|
21
|
+
const panes = new Set(listPanes(deps.tmux).map((p) => p.target));
|
|
22
|
+
for (const task of ledger.tasksWhere(deps.repo, ["berjalan"])) {
|
|
23
|
+
const agent = readAgents(deps.registryFile).find((a) => a.name === task.agent);
|
|
24
|
+
const emit = (kind, line, status) => {
|
|
25
|
+
ledger.addEvent(task.id, kind, line);
|
|
26
|
+
if (status)
|
|
27
|
+
ledger.setStatus(task.id, status);
|
|
28
|
+
keluar.push(line);
|
|
29
|
+
};
|
|
30
|
+
const kepala = `T${task.id} ${task.agent}`;
|
|
31
|
+
let tampak;
|
|
32
|
+
if (agent && panes.has(agent.tmux)) {
|
|
33
|
+
try {
|
|
34
|
+
tampak = transport.tampak(agent.tmux);
|
|
35
|
+
}
|
|
36
|
+
catch {
|
|
37
|
+
tampak = undefined;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
if (!agent || !tampak) {
|
|
41
|
+
emit("macet", `${kepala} macet: agent hilang`, "macet");
|
|
42
|
+
continue;
|
|
43
|
+
}
|
|
44
|
+
await reaksi(task, agent, tampak);
|
|
45
|
+
async function reaksi(t, a, layar) {
|
|
46
|
+
const sekarang = ledger.now();
|
|
47
|
+
const hash = hashLayar(layar.baris.join("\n"));
|
|
48
|
+
let sejak = t.scrSince ?? sekarang;
|
|
49
|
+
let flag = t.flag;
|
|
50
|
+
if (t.scrHash === undefined)
|
|
51
|
+
ledger.patch(t.id, { scrHash: hash, scrSince: sejak });
|
|
52
|
+
else if (t.scrHash !== hash) {
|
|
53
|
+
sejak = sekarang;
|
|
54
|
+
flag = undefined;
|
|
55
|
+
ledger.patch(t.id, { scrHash: hash, scrSince: sejak, flag: null });
|
|
56
|
+
}
|
|
57
|
+
const diam = sekarang - sejak;
|
|
58
|
+
const sekali = (kind, line, status) => {
|
|
59
|
+
if (flag === kind)
|
|
60
|
+
return;
|
|
61
|
+
flag = kind;
|
|
62
|
+
ledger.patch(t.id, { flag: kind });
|
|
63
|
+
emit(kind, line, status);
|
|
64
|
+
};
|
|
65
|
+
const token = `rempug brief T${t.id}`;
|
|
66
|
+
const keadaan = klasifikasi({
|
|
67
|
+
baris: layar.baris,
|
|
68
|
+
kursorY: layar.kursorY,
|
|
69
|
+
berubah: diam < o.diamDetik,
|
|
70
|
+
token,
|
|
71
|
+
});
|
|
72
|
+
if (keadaan === "bekerja")
|
|
73
|
+
return;
|
|
74
|
+
const batasAck = Math.max(o.ackDetik, ((a.ukur?.ackMs ?? 0) / 1000) * 3);
|
|
75
|
+
if (!t.ackedAt && sekarang - t.sentAt < batasAck)
|
|
76
|
+
return;
|
|
77
|
+
if (keadaan === "menunggu-izin")
|
|
78
|
+
return sekali("menunggu-izin", `${kepala} menunggu-izin: butuh persetujuan manusia di sesi ${a.tmux}`);
|
|
79
|
+
if (keadaan === "error")
|
|
80
|
+
return sekali("limit", `${kepala} limit: agent melaporkan galat limit, kuota, atau autentikasi; lihat layar agent`, "macet");
|
|
81
|
+
if (keadaan === "bertanya")
|
|
82
|
+
return sekali("bertanya", `${kepala} bertanya: ${pertanyaan(layar.baris) ?? "?"} | jawab: rempug jawab T${t.id} "<teks>"`);
|
|
83
|
+
if (!t.ackedAt) {
|
|
84
|
+
if (keadaan === "tertahan")
|
|
85
|
+
return tertahanAck(t, a);
|
|
86
|
+
return sekali("diterima-tanpa-ack", `${kepala} diterima-tanpa-ack: pointer terkirim tetapi agent belum menjalankan rempug; dugaan: tidak mengikuti protokol atau berpikir lama`);
|
|
87
|
+
}
|
|
88
|
+
// Sudah ack, layar diam, tidak ada pertanyaan atau izin: agent kemungkinan selesai tanpa membalas.
|
|
89
|
+
if (t.pengingat === 0) {
|
|
90
|
+
if (diam < o.diamDetik * 2)
|
|
91
|
+
return;
|
|
92
|
+
await transport.kirim(a.tmux, `Pengingat: tugas T${t.id} belum dibalas. Jalankan \`rempug reply T${t.id}\` (isi lewat stdin) bila sudah selesai.`, a.kirim ?? PROFIL_BAWAAN);
|
|
93
|
+
ledger.patch(t.id, { pengingat: 1, scrSince: sekarang });
|
|
94
|
+
return;
|
|
95
|
+
}
|
|
96
|
+
if (diam >= o.macetDetik)
|
|
97
|
+
emit("macet", `${kepala} macet: layar diam ${diam} dtk setelah pengingat, tanpa balasan`, "macet");
|
|
98
|
+
}
|
|
99
|
+
async function tertahanAck(t, a) {
|
|
100
|
+
if (t.upaya >= o.maksUpaya) {
|
|
101
|
+
updateAgent(deps.registryFile, a.name, {
|
|
102
|
+
gagalBeruntun: (a.gagalBeruntun ?? 0) + 1,
|
|
103
|
+
});
|
|
104
|
+
return emit("tersangkut", `${kepala} tersangkut: pointer tertahan di kotak input setelah ${o.maksUpaya} percobaan`, "macet");
|
|
105
|
+
}
|
|
106
|
+
const profil = a.kirim ?? PROFIL_BAWAAN;
|
|
107
|
+
ledger.patch(t.id, { upaya: t.upaya + 1, scrSince: ledger.now() });
|
|
108
|
+
if (t.upaya + 1 < o.maksUpaya)
|
|
109
|
+
await transport.tekan(a.tmux, profil.submit);
|
|
110
|
+
else
|
|
111
|
+
await transport.kirim(a.tmux, pointer(t.id), {
|
|
112
|
+
...profil,
|
|
113
|
+
sebelum: ["C-u"],
|
|
114
|
+
submit: ["Enter", "Enter"],
|
|
115
|
+
});
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
return keluar;
|
|
119
|
+
}
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
import { spawnSync } from "node:child_process";
|
|
2
|
+
export function runTmux(args, opts = {}, input) {
|
|
3
|
+
return spawnSync("tmux", [...(opts.socket ? ["-L", opts.socket] : []), ...args], { encoding: "utf8", input });
|
|
4
|
+
}
|
|
5
|
+
/** Semua pane di semua sesi; daftar kosong bila tmux tidak ada atau belum ada server. */
|
|
6
|
+
export function listPanes(opts = {}) {
|
|
7
|
+
const format = [
|
|
8
|
+
"#{session_name}",
|
|
9
|
+
"#{window_index}",
|
|
10
|
+
"#{pane_index}",
|
|
11
|
+
"#{pane_id}",
|
|
12
|
+
"#{pane_current_command}",
|
|
13
|
+
"#{pane_current_path}",
|
|
14
|
+
].join("\t");
|
|
15
|
+
const result = runTmux(["list-panes", "-a", "-F", format], opts);
|
|
16
|
+
if (result.error || result.status !== 0)
|
|
17
|
+
return [];
|
|
18
|
+
return result.stdout
|
|
19
|
+
.split("\n")
|
|
20
|
+
.filter(Boolean)
|
|
21
|
+
.map((line) => {
|
|
22
|
+
const [session = "", window = "0", pane = "0", paneId = "", command = "", path = "",] = line.split("\t");
|
|
23
|
+
return {
|
|
24
|
+
session,
|
|
25
|
+
window: Number(window),
|
|
26
|
+
pane: Number(pane),
|
|
27
|
+
paneId,
|
|
28
|
+
command,
|
|
29
|
+
path,
|
|
30
|
+
target: `${session}:${window}.${pane}`,
|
|
31
|
+
};
|
|
32
|
+
});
|
|
33
|
+
}
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import { PROFIL_BAWAAN } from "./profile.js";
|
|
2
|
+
import { runTmux } from "./tmux.js";
|
|
3
|
+
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
4
|
+
export function tmuxTransport(opts = {}) {
|
|
5
|
+
// "=" memaksa pencocokan nama sesi persis; tanpanya sesi bernama "1" dibaca sebagai nomor pane.
|
|
6
|
+
const tujuan = (target) => `=${target}`;
|
|
7
|
+
const run = (args, input) => {
|
|
8
|
+
const result = runTmux(args, opts, input);
|
|
9
|
+
if (result.status !== 0)
|
|
10
|
+
throw new Error(`tmux ${args[0]} gagal: ${result.stderr.trim() || result.error?.message || "tidak diketahui"}`);
|
|
11
|
+
};
|
|
12
|
+
const tekan = async (target, keys) => {
|
|
13
|
+
for (const key of keys)
|
|
14
|
+
run(["send-keys", "-t", tujuan(target), key]);
|
|
15
|
+
};
|
|
16
|
+
return {
|
|
17
|
+
tekan,
|
|
18
|
+
async kirim(target, baris, profil = PROFIL_BAWAAN) {
|
|
19
|
+
await tekan(target, profil.sebelum);
|
|
20
|
+
if (profil.suntik === "keys")
|
|
21
|
+
run(["send-keys", "-t", tujuan(target), "-l", baris]);
|
|
22
|
+
else {
|
|
23
|
+
const buffer = `rempug-${process.pid}`;
|
|
24
|
+
run(["load-buffer", "-b", buffer, "-"], baris);
|
|
25
|
+
run(["paste-buffer", "-p", "-d", "-b", buffer, "-t", tujuan(target)]);
|
|
26
|
+
}
|
|
27
|
+
await sleep(profil.jeda_ms);
|
|
28
|
+
await tekan(target, profil.submit);
|
|
29
|
+
},
|
|
30
|
+
tampak(target) {
|
|
31
|
+
const layar = runTmux(["capture-pane", "-p", "-t", tujuan(target)], opts);
|
|
32
|
+
if (layar.status !== 0)
|
|
33
|
+
throw new Error(`tmux capture-pane gagal: ${layar.stderr.trim()}`);
|
|
34
|
+
const kursor = runTmux(["display-message", "-p", "-t", tujuan(target), "#{cursor_y}"], opts);
|
|
35
|
+
const y = Number.parseInt(kursor.stdout.trim(), 10);
|
|
36
|
+
return {
|
|
37
|
+
baris: layar.stdout.replace(/\n$/, "").split("\n"),
|
|
38
|
+
kursorY: Number.isNaN(y) ? undefined : y,
|
|
39
|
+
};
|
|
40
|
+
},
|
|
41
|
+
layar(target, baris = 40) {
|
|
42
|
+
const result = runTmux(["capture-pane", "-p", "-t", tujuan(target), "-S", `-${baris}`], opts);
|
|
43
|
+
if (result.status !== 0)
|
|
44
|
+
throw new Error(`tmux capture-pane gagal: ${result.stderr.trim()}`);
|
|
45
|
+
return result.stdout;
|
|
46
|
+
},
|
|
47
|
+
};
|
|
48
|
+
}
|