agen-vektor 0.3.27 → 0.3.28

package/dist/agent/checkpoints.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeCheckpoint = takeCheckpoint;
+exports.listCheckpoints = listCheckpoints;
+exports.restoreCheckpoint = restoreCheckpoint;
+exports.pruneCheckpoints = pruneCheckpoints;
+exports.resetCheckpoints = resetCheckpoints;
+/**
+ * Checkpoints — git-based safety net (Freebuff/Codebuff parity).
+ *
+ * Every run, before the FIRST mutating tool call (write_file / edit_file /
+ * delete_file / apply_patch / shell) touches the project, the agent takes a
+ * CHECKPOINT: a full snapshot of the working tree stored in a SHADOW git
+ * repository under ~/.vector/checkpoints/<project>/.
+ *
+ * Design rules:
+ * - The USER'S repo is never touched: no commits, no branches, no refs, no
+ *   hooks. The shadow repo is a SEPARATE GIT_DIR (own object store, index,
+ *   refs) using the project tree as its work-tree. `git status` in the user's
+ *   project stays pristine — verified by tests.
+ * - Each checkpoint is an INDEPENDENT root commit (git commit-tree, no
+ *   parent) pinned by its own ref `refs/vector-cp/<ref>`. Unchanged files
+ *   dedupe by content in the object store, so snapshots stay small — and
+ *   pruning is a plain ref deletion, no history rewrite.
+ * - Restore = index reset to the snapshot ref + `checkout <ref> -- .` +
+ *   resurrection of files deleted after the snapshot. The user's git history
+ *   is untouched (their unstaged changes are replaced — they can still diff
+ *   via their own git BEFORE restoring; /undo warns in the TUI).
+ * - Bounded storage: keep the newest MAX_CHECKPOINTS refs, delete the rest.
+ * - Everything is best-effort: a missing git binary or a read-only home must
+ *   NEVER break a run. All failures resolve to null/empty and the run
+ *   proceeds without a safety net.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = require("../utils/paths");
+const MAX_CHECKPOINTS = 30;
+const REF_PREFIX = 'refs/vector-cp/';
+const GIT = 'git';
+// Monotonic per-process sequence: same-second snapshots must keep their
+// creation order in listings (restore-by-index!), so the ref suffix is a
+// zero-padded base36 counter instead of random chars — ref-name sort then
+// equals reverse-creation order everywhere.
+let cpSeq = 0;
+function gitDirFor(cwd) {
+    // Stable per project path — two projects never share a shadow repo.
+    const slug = cwd.replace(/[^a-zA-Z0-9._-]+/g, '_').slice(-80) || 'project';
+    return path.join((0, paths_1.getVectorDir)(), 'checkpoints', slug);
+}
+function git(gitDir, args, workTree) {
+    const r = (0, node_child_process_1.spawnSync)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], { encoding: 'utf8', timeout: 20_000 });
+    return { ok: r.status === 0, out: (r.stdout || '') + (r.stderr || '') };
+}
+function ensureShadowRepo(gitDir) {
+    try {
+        if (!fs.existsSync(path.join(gitDir, 'HEAD'))) {
+            fs.mkdirSync(gitDir, { recursive: true });
+            // Fixed identity — nothing from the user's git config leaks in.
+            if (!git(gitDir, ['init', '--quiet']).ok)
+                return false;
+            git(gitDir, ['config', 'user.email', 'checkpoints@vectorhead.local']);
+            git(gitDir, ['config', 'user.name', 'VectorHead Checkpoints']);
+            git(gitDir, ['config', 'commit.gpgsign', 'false']);
+            git(gitDir, ['config', 'core.autocrlf', 'false']);
+            git(gitDir, ['config', 'gc.auto', '0']);
+        }
+        return fs.existsSync(path.join(gitDir, 'HEAD'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Take a checkpoint. Returns null when snapshotting is impossible — callers
+ * must treat that as "no safety net", never as an error.
+ */
+function takeCheckpoint(cwd, reason, task = '') {
+    try {
+        if (!fs.existsSync(cwd))
+            return null;
+        const gitDir = gitDirFor(cwd);
+        if (!ensureShadowRepo(gitDir))
+            return null;
+        // -A stages the full tree incl. deletions and untracked files. A
+        // .gitignore in the user's project is respected (their intent), but
+        // that also means ignored files are NOT protected by checkpoints —
+        // documented trade-off, same as Claude Code.
+        if (!git(gitDir, ['add', '-A', '--'], cwd).ok)
+            return null;
+        const tree = git(gitDir, ['write-tree']);
+        if (!tree.ok)
+            return null;
+        const treeHash = tree.out.trim().split('\n')[0].trim();
+        if (!/^[0-9a-f]{40}$/.test(treeHash))
+            return null;
+        const stamp = new Date();
+        const pad = (n) => String(n).padStart(2, '0');
+        const t = `${stamp.getFullYear()}${pad(stamp.getMonth() + 1)}${pad(stamp.getDate())}` +
+            `-${pad(stamp.getHours())}${pad(stamp.getMinutes())}${pad(stamp.getSeconds())}`;
+        const suffix = (cpSeq++).toString(36).padStart(4, '0');
+        const ref = `cp-${t}-${suffix}`;
+        const msg = `checkpoint ${ref} (${reason}) ${task.slice(0, 80)}`.trim();
+        // Independent root commit — commit-tree gives full control over parents.
+        const commit = git(gitDir, ['commit-tree', treeHash, '-m', msg]);
+        if (!commit.ok)
+            return null;
+        const hash = commit.out.trim().split('\n')[0].trim();
+        if (!/^[0-9a-f]{40}$/.test(hash))
+            return null;
+        if (!git(gitDir, ['update-ref', `${REF_PREFIX}${ref}`, hash]).ok)
+            return null;
+        return { ref, time: stamp.toISOString(), reason, task: task.slice(0, 80), hash };
+    }
+    catch {
+        return null;
+    }
+}
+/** Newest-first list of surviving checkpoints. */
+function listCheckpoints(cwd) {
+    try {
+        const gitDir = gitDirFor(cwd);
+        if (!fs.existsSync(path.join(gitDir, 'HEAD')))
+            return [];
+        const r = git(gitDir, [
+            'for-each-ref',
+            `--format=%(refname)%09%(contents:subject)%09%(committerdate:iso-strict)`,
+            REF_PREFIX,
+        ]);
+        if (!r.ok)
+            return [];
+        const out = [];
+        for (const line of r.out.split('\n')) {
+            if (line.trim() === '')
+                continue;
+            const [refname = '', subject = '', time = ''] = line.split('\t');
+            const ref = refname.replace(REF_PREFIX, '');
+            const m = subject.match(/^(cp-[0-9]{8}-[0-9]{6}-[a-z0-9]+) \(([^)]*)\) ?(.*)$/);
+            const hash = git(gitDir, ['rev-parse', `${REF_PREFIX}${ref}`]).out.trim();
+            if (!/^[0-9a-f]{40}$/.test(hash))
+                continue;
+            out.push({
+                ref: m ? m[1] : ref,
+                time: time.trim(),
+                reason: m ? m[2] : '',
+                task: m ? m[3] : subject,
+                hash,
+            });
+        }
+        // Same-second snapshots tie on committerdate — the ref name embeds a
+        // fixed-width timestamp, so sort on THAT (newest first) in JS instead of
+        // relying on git tie-breaking.
+        out.sort((a, b) => (a.ref < b.ref ? 1 : a.ref > b.ref ? -1 : 0));
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Restore the working tree to a checkpoint (index into the newest-first
+ * list, an exact ref suffix, or a full hash). Files deleted AFTER the
+ * snapshot are resurrected; files the snapshot never tracked are left
+ * alone. Returns a user-facing message either way.
+ */
+function restoreCheckpoint(cwd, refOrIndex) {
+    const list = listCheckpoints(cwd);
+    if (list.length === 0)
+        return { ok: false, message: 'No checkpoints yet.' };
+    let cp;
+    if (typeof refOrIndex === 'number') {
+        if (refOrIndex < 0 || refOrIndex >= list.length)
+            return { ok: false, message: 'Checkpoint index out of range.' };
+        cp = list[refOrIndex];
+    }
+    else {
+        cp = list.find((c) => c.ref === refOrIndex || c.hash === refOrIndex);
+        if (!cp)
+            return { ok: false, message: `Unknown checkpoint "${refOrIndex}".` };
+    }
+    const gitDir = gitDirFor(cwd);
+    const target = cp; // bounds-checked above
+    // index := snapshot tree, then materialize the whole tree over the
+    // work-tree (restores modified AND deleted files).
+    if (!git(gitDir, ['read-tree', '--reset', '-u', target.hash], cwd).ok) {
+        return { ok: false, message: `restore failed: read-tree ${target.ref}` };
+    }
+    const checkout = git(gitDir, ['checkout', target.hash, '--', '.'], cwd);
+    if (!checkout.ok) {
+        return { ok: false, message: `restore failed: ${checkout.out.trim().slice(0, 200)}` };
+    }
+    // read-tree -u handles deletions of tracked files already; walk the
+    // snapshot tree to be extra safe about paths git skipped.
+    const ls = git(gitDir, ['ls-tree', '-r', '--name-only', target.hash]);
+    if (ls.ok) {
+        for (const f of ls.out.split('\n')) {
+            const p = f.trim();
+            if (p && !fs.existsSync(path.join(cwd, p))) {
+                git(gitDir, ['checkout', target.hash, '--', p], cwd);
+            }
+        }
+    }
+    return { ok: true, message: `Restored to checkpoint ${target.ref} (${target.time}).` };
+}
+/** Keep only the newest MAX_CHECKPOINTS refs (best-effort, storage bound). */
+function pruneCheckpoints(cwd) {
+    try {
+        const gitDir = gitDirFor(cwd);
+        if (!fs.existsSync(path.join(gitDir, 'HEAD')))
+            return;
+        const list = listCheckpoints(cwd);
+        for (const cp of list.slice(MAX_CHECKPOINTS)) {
+            git(gitDir, ['update-ref', '-d', `${REF_PREFIX}${cp.ref}`]);
+        }
+        // Drop unreferenced objects occasionally — cheap, bounded.
+        if (list.length > MAX_CHECKPOINTS)
+            git(gitDir, ['gc', '--quiet', '--prune=now']);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Test helper: wipe the shadow repo for a project. */
+function resetCheckpoints(cwd) {
+    try {
+        fs.rmSync(gitDirFor(cwd), { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/agent/loop.js

@@ -15,6 +15,7 @@ exports.estimateContextSize = estimateContextSize;
  */
 const provider_1 = require("../providers/provider");
 const context_1 = require("./context");
+const checkpoints_1 = require("./checkpoints");
 const light_1 = require("./light");
 const prompts_1 = require("./prompts");
 const rules_1 = require("./rules");
@@ -139,6 +140,22 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     let stopped = false;
     let finalContent = '';
     let lastReasoning = '';
+    // ─── Checkpoints (git-based safety net, Freebuff/Codebuff parity) ───
+    // Armed lazily: the snapshot is taken right before the FIRST mutating
+    // tool call of the run (never for pure read/chat runs), once per run.
+    // Best-effort: null = no net, the run proceeds regardless.
+    const MUTATING_TOOLS = new Set(['write_file', 'edit_file', 'delete_file', 'apply_patch', 'shell', 'git', 'run_in_background']);
+    let checkpointTaken = false;
+    const maybeCheckpoint = (toolName) => {
+        if (checkpointTaken || !MUTATING_TOOLS.has(toolName))
+            return;
+        checkpointTaken = true;
+        const cp = (0, checkpoints_1.takeCheckpoint)(cwd, toolName, userRequest);
+        if (cp) {
+            callbacks.onStatus?.(`Checkpoint siap (${cp.ref})`);
+            callbacks.onActivity?.('checkpoint', `safety snapshot ${cp.ref}`);
+        }
+    };
     const checkAbort = () => {
         if (signal?.aborted) {
             aborted = true;
@@ -420,6 +437,11 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                 for (const batch of batches) {
                     checkAbort();
                     const parallel = batch.length > 1 && batch.every((tc) => PARALLEL_TOOLS.has(tc.name));
+                    // Safety net BEFORE the first mutating call of this run — armed
+                    // once, lazily; parallel batches are read-only by construction and
+                    // never trigger it.
+                    if (!parallel)
+                        maybeCheckpoint(batch[0].name);
                     toolCalls += batch.length;
                     if (!parallel) {
                         callbacks.onStatus?.(`Running ${batch[0].name}`);

package/dist/config/config.js

@@ -67,7 +67,11 @@ exports.DEFAULT_CONFIG = {
     // so the guardrail floor stays intact. Opt back into prompting via
     // VECTOR_ASK=1 or the /mode toggle in the TUI.
     permissionMode: 'yolo',
-    maxIterations: 25,
+    // 50 (dulu 25): task panjang sering mati di tengah — "runs out of
+    // iterations" — padahal agen masih di jalur yang benar. Naik tanpa
+    // risiko: iteration = 1 langkah agen (LLM call + tools), bukan 1 API
+    // key query; kuota gateway dijaga rate-limit per-request di sisi gateway.
+    maxIterations: 50,
     maxRetries: 3,
     requestTimeoutMs: 120_000,
     extraModels: {},

package/dist/tui/app.js

@@ -59,6 +59,7 @@ const commands_1 = require("./commands");
 const suggest_1 = require("./suggest");
 const mcp_1 = require("../tools/mcp");
 const provider_1 = require("../providers/provider");
+const checkpoints_1 = require("../agent/checkpoints");
 const planner_1 = require("../agent/planner");
 const extras_1 = require("../tools/extras");
 const session_1 = require("../agent/session");
@@ -2163,6 +2164,17 @@ class App {
             case '/session':
                 this.modal = { type: 'session', selected: 0, start: 0 };
                 break;
+            case '/undo': {
+                // Freebuff/Codebuff-style safety net: pick a checkpoint (auto taken
+                // before the first mutating tool call of each run) and restore it.
+                const checkpoints = (0, checkpoints_1.listCheckpoints)(this.agent.cwd);
+                if (checkpoints.length === 0) {
+                    this.addSystem('Belum ada checkpoint — snapshot dibuat otomatis sebelum tool menulis pertama kali di sebuah run.');
+                    break;
+                }
+                this.modal = { type: 'undo', selected: 0, start: 0, checkpoints };
+                break;
+            }
             case '/settings':
                 this.modal = { type: 'settings' };
                 break;
@@ -2414,8 +2426,11 @@ class App {
                 // Esc still closes. Changes persist via saveConfig immediately.
                 {
                     const cfg = this.agent.config;
+                    // Cap 999 (dulu 200): task besar (refactor menyeluruh, migrasi,
+                    // riset panjang) butuh budget lebih — 200 sering masih kurang.
+                    const cap = 999;
                     const step = (d) => {
-                        const next = Math.min(200, Math.max(1, cfg.maxIterations + d));
+                        const next = Math.min(cap, Math.max(1, cfg.maxIterations + d));
                         if (next === cfg.maxIterations)
                             return;
                         cfg.maxIterations = next;
@@ -2451,7 +2466,7 @@ class App {
                     else if (ev.name === 'char' && ev.char && /[0-9]/.test(ev.char)) {
                         // Number keys type the exact value (not digit-append — no
                         // visible field, so append would be invisible state).
-                        const next = Math.min(200, Math.max(1, Number(ev.char)));
+                        const next = Math.min(cap, Math.max(1, Number(ev.char)));
                         if (next !== cfg.maxIterations) {
                             cfg.maxIterations = next;
                             try {
@@ -2527,6 +2542,41 @@ class App {
                     this.modal = { type: 'none' };
                 });
                 break;
+            case 'undo': {
+                const cps = modal.checkpoints;
+                await this.handleSelector(modal, ev, cps.map((c) => ({
+                    label: `${c.time.replace('T', ' ').slice(0, 19)} — ${c.task || c.reason}`,
+                    value: c.ref,
+                    hint: c.reason,
+                })), async (sel) => {
+                    this.modal = { type: 'none' };
+                    if (this.running) {
+                        this.addSystem('Tidak bisa restore saat agen sedang jalan — hentikan dulu (Esc).');
+                        return;
+                    }
+                    // Confirm: restore MENIMPA perubahan yang belum di-commit.
+                    this.modal = {
+                        type: 'confirm',
+                        title: 'Restore checkpoint',
+                        body: [
+                            `Kembalikan seluruh file project ke snapshot ${sel.value}?`,
+                            '',
+                            'Perubahan yang BELUM di-commit akan tertimpa (riwayat git kamu tetap utuh —',
+                            'restore hanya menyentuh working tree).',
+                        ],
+                        focused: 'cancel',
+                        resolve: async (ok) => {
+                            this.modal = { type: 'none' };
+                            if (!ok)
+                                return;
+                            const r = (0, checkpoints_1.restoreCheckpoint)(this.agent.cwd, sel.value);
+                            this.addSystem(r.ok ? `⏪ ${r.message}` : `! ${r.message}`);
+                            this.markDirty();
+                        },
+                    };
+                });
+                break;
+            }
             case 'session': {
                 const sessions = (0, session_1.listSessions)();
                 await this.handleSelector(modal, ev, sessions.map((s) => ({ label: s.name, value: s.name, hint: `${s.messageCount} msgs` })), async (s) => {
@@ -3324,7 +3374,7 @@ class App {
                         label('Mode', this.agent.config.permissionMode),
                         // LIVE-EDITABLE: +/- / ↑↓ / PgUp-PgDn step the budget, digits
                         // type an exact value — persisted to ~/.vector/config.json.
-                        label('Max iterations', `${this.agent.config.maxIterations}  ${theme_1.THEME.muted}(+/- / ↑↓ / PgUp-PgDn / angka)${theme_1.THEME.reset}`),
+                        label('Max iterations', `${this.agent.config.maxIterations}  ${theme_1.THEME.muted}(+/- / ↑↓ / PgUp-PgDn / angka · cap 999)${theme_1.THEME.reset}`),
                         label('Max retries', String(this.agent.config.maxRetries)),
                         label('API URL', this.agent.config.apiUrl || '(default)'),
                         label('Key configured', (0, credentials_1.hasApiKey)(this.agent.config.provider) ? 'yes' : 'no'),
@@ -3414,6 +3464,22 @@ class App {
                     cols,
                 });
             }
+            case 'undo': {
+                return (0, components_1.renderSelector)({
+                    title: 'Restore checkpoint',
+                    options: m.checkpoints.length > 0
+                        ? m.checkpoints.map((c) => ({
+                            label: `${c.time.replace('T', ' ').slice(0, 19)} — ${c.task || c.reason}`,
+                            value: c.ref,
+                            hint: c.reason,
+                        }))
+                        : [{ label: '(no checkpoints yet)', value: '' }],
+                    selected: m.selected,
+                    start: m.start,
+                    rows,
+                    cols,
+                });
+            }
             case 'theme': {
                 const themes = (0, themes_1.listThemes)();
                 return (0, components_1.renderSelector)({

package/dist/tui/commands.js

@@ -23,6 +23,7 @@ exports.COMMANDS = [
     { id: 'model', description: 'select model for the active provider' },
     { id: 'theme', description: 'select theme (OpenCode-style)' },
     { id: 'session', description: 'manage sessions (list / switch)' },
+    { id: 'undo', description: 'restore project files to a checkpoint (auto-snapshot before edits)' },
     { id: 'session-name', description: 'set session name (arg optional)' },
     { id: 'settings', description: 'view settings (provider, model, limits, files)' },
     { id: 'mcp', description: 'MCP servers — probe config, list tools per server' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agen-vektor",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "description": "VectorHead (agen-vektor) — AI Coding Agent CLI/TUI for Linux & Termux. Multi-provider, tool calling, session, permission system.",
   "type": "commonjs",
   "bin": {