agen-vektor 0.3.30 → 0.3.32

package/dist/agent/agent.js

@@ -5,6 +5,7 @@ const factory_1 = require("../providers/factory");
 const registry_1 = require("../tools/registry");
 const filesystem_1 = require("../tools/filesystem");
 const search_1 = require("../tools/search");
+const semantic_search_1 = require("../tools/semantic-search");
 const shell_1 = require("../tools/shell");
 const git_1 = require("../tools/git");
 const web_1 = require("../tools/web");
@@ -59,6 +60,9 @@ class Agent {
         this.tools.registerMany([
             ...(0, filesystem_1.createFilesystemTools)(),
             ...(0, search_1.createSearchTools)(),
+            // Semantic code search (via gateway embeddings relay): semantic_index /
+            // semantic_search — cari kode by MEANING, zero-config (key di gateway).
+            ...(0, semantic_search_1.createSemanticSearchTools)(),
             (0, shell_1.createShellTool)(),
             (0, git_1.createGitTool)(),
             ...(0, web_1.createWebTools)(),

package/dist/agent/checkpoints.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeCheckpoint = takeCheckpoint;
+exports.takeCheckpointAsync = takeCheckpointAsync;
 exports.listCheckpoints = listCheckpoints;
 exports.restoreCheckpoint = restoreCheckpoint;
 exports.pruneCheckpoints = pruneCheckpoints;
@@ -63,6 +64,17 @@ exports.resetCheckpoints = resetCheckpoints;
  * - 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.
+ *
+ * Latency rules (bug "mentok di Edit", 2026-09-15):
+ * - The agent loop uses takeCheckpointAsync (off the event loop) so the TUI
+ *   keeps painting while a big tree is scanned; the tool card renders BEFORE
+ *   the snapshot starts (loop.ts), never behind it.
+ * - node_modules / .vector / .git are excluded from BOTH the size-count walk
+ *   and the actual `git add` (pathspec excludes) — a bare /root work-tree
+ *   used to stage 84k files ≈ 41s per snapshot and ballooned the shadow repo
+ *   to 521 MB.
+ * - Work-trees above CP_MAX_FILES candidate files skip the snapshot entirely:
+ *   the net costs more than it protects there.
  */
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
@@ -82,9 +94,122 @@ function gitDirFor(cwd) {
     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 });
+    const r = (0, node_child_process_1.spawnSync)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], 
+    // cwd MUST be the work-tree when one is set: git resolves relative
+    // pathspecs (our `:(exclude)` patterns) against the process cwd — from a
+    // different directory the excludes silently stop matching (probe-proven).
+    { encoding: 'utf8', timeout: 20_000, ...(workTree ? { cwd: workTree } : {}) });
     return { ok: r.status === 0, out: (r.stdout || '') + (r.stderr || '') };
 }
+/** Async variant of `git(...)` — the child runs off the event loop so the
+ * TUI keeps rendering while a big snapshot scans the tree. 120s timeout
+ * (a slow disk scanning 100k+ files must not wedge the run forever). */
+function gitAsync(gitDir, args, workTree) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(GIT, [`--git-dir=${gitDir}`, ...(workTree ? [`--work-tree=${workTree}`] : []), ...args], 
+            // Same cwd rule as git(): relative pathspecs resolve against cwd.
+            { stdio: ['ignore', 'pipe', 'pipe'], ...(workTree ? { cwd: workTree } : {}) });
+        }
+        catch {
+            resolve({ ok: false, out: 'spawn failed' });
+            return;
+        }
+        let out = '';
+        let done = false;
+        const finish = (ok, tail) => {
+            if (done)
+                return;
+            done = true;
+            resolve({ ok, out: out.slice(-4000) + tail });
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* ignore */
+            }
+            finish(false, '\ngit timeout');
+        }, 120_000);
+        child.stdout?.on('data', (d) => {
+            out += d.toString();
+            if (out.length > 4096)
+                out = out.slice(-2048); // bounded
+        });
+        child.stderr?.on('data', (d) => {
+            out += d.toString();
+            if (out.length > 4096)
+                out = out.slice(-2048);
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            finish(false, '\nspawn error');
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            finish(code === 0, code === 0 ? '' : `\nexit ${code}`);
+        });
+    });
+}
+/**
+ * Folders the safety net should NEVER track even when the project has no
+ * .gitignore of its own: dependency folders and vector's own state (a
+ * ~/.vector tree inside the work-tree would make the snapshot
+ * self-referential and explode the object store — seen live: 521 MB shadow
+ * repo for /root).
+ */
+const CP_EXCLUDE = ['node_modules', '.vector', '.git'];
+/** Upper bound on work-tree scan size: beyond this, snapshotting takes
+ * minutes (VPS bench: 84k files = 41s per run) and the safety net costs
+ * more than it protects — skip with a clear reason instead. */
+const CP_MAX_FILES = 20_000;
+function countCandidateFiles(cwd) {
+    try {
+        let n = 0;
+        const walk = (dir, depth) => {
+            if (depth > 12 || n > CP_MAX_FILES)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                if (CP_EXCLUDE.includes(e.name))
+                    continue;
+                if (e.isDirectory())
+                    walk(path.join(dir, e.name), depth + 1);
+                else if (e.isFile()) {
+                    n++;
+                    if (n > CP_MAX_FILES)
+                        return;
+                }
+            }
+        };
+        walk(cwd, 0);
+        return n;
+    }
+    catch {
+        return null;
+    }
+}
+/** `git add -A` arguments with the exclude pathspecs applied. Runs with
+ * cwd = work-tree (see git()/gitAsync()), so the excludes are RELATIVE to
+ * the work-tree root: the bare name excludes the top-level folder and the
+ * trailing-slash glob excludes nested ones (git 2.43 probe-verified — the
+ * glob alone misses the root folder). */
+function addArgs() {
+    const excludes = [];
+    for (const d of CP_EXCLUDE) {
+        excludes.push(`:(exclude)${d}`);
+        excludes.push(`:(exclude)**/${d}/`);
+    }
+    return ['add', '-A', '--', '.', ...excludes];
+}
 function ensureShadowRepo(gitDir) {
     try {
         if (!fs.existsSync(path.join(gitDir, 'HEAD'))) {
@@ -104,9 +229,24 @@ function ensureShadowRepo(gitDir) {
         return false;
     }
 }
+function stampRef(reason, task) {
+    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();
+    return { ref, time: stamp.toISOString(), msg, stamp };
+}
+function parseHash(out) {
+    const hash = out.trim().split('\n')[0]?.trim() ?? '';
+    return /^[0-9a-f]{40}$/.test(hash) ? hash : null;
+}
 /**
- * Take a checkpoint. Returns null when snapshotting is impossible — callers
- * must treat that as "no safety net", never as an error.
+ * Take a checkpoint (SYNC legacy path). Returns null when snapshotting is
+ * impossible — callers must treat that as "no safety net", never as an
+ * error. The agent loop uses the async variant below.
  */
 function takeCheckpoint(cwd, reason, task = '') {
     try {
@@ -115,35 +255,79 @@ function takeCheckpoint(cwd, reason, task = '') {
         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)
+        // -A stages the full tree incl. deletions and untracked files, minus the
+        // CP_EXCLUDE folders (pathspec excludes). 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, addArgs(), 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))
+        const treeHash = parseHash(tree.out);
+        if (!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();
+        const { ref, time, msg } = stampRef(reason, task);
         // 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))
+        const hash = parseHash(commit.out);
+        if (!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 };
+        return { ref, time, reason, task: task.slice(0, 80), hash };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ASYNC checkpoint for the agent loop: same guarantees as takeCheckpoint,
+ * but the git child processes run off the event loop so the TUI keeps
+ * painting (Working line, spinner) while a big tree is scanned. Additional
+ * guards the sync version never had:
+ * - skip when the work-tree exceeds CP_MAX_FILES candidate files,
+ * - prune old refs after a successful snapshot so the shadow repo stays
+ *   bounded (seen live: 521 MB after a week without pruning).
+ */
+async function takeCheckpointAsync(cwd, reason, task = '') {
+    try {
+        if (!fs.existsSync(cwd))
+            return null;
+        const n = countCandidateFiles(cwd);
+        if (n !== null && n > CP_MAX_FILES)
+            return null;
+        const gitDir = gitDirFor(cwd);
+        if (!ensureShadowRepo(gitDir))
+            return null;
+        // -A stages the full tree incl. deletions and untracked files, minus
+        // CP_EXCLUDE via pathspec excludes (the candidate walk above is only
+        // the size guard; git itself must also skip the folders).
+        const add = await gitAsync(gitDir, addArgs(), cwd);
+        if (!add.ok)
+            return null;
+        const tree = await gitAsync(gitDir, ['write-tree']);
+        if (!tree.ok)
+            return null;
+        const treeHash = parseHash(tree.out);
+        if (!treeHash)
+            return null;
+        const { ref, time, msg } = stampRef(reason, task);
+        const commit = await gitAsync(gitDir, ['commit-tree', treeHash, '-m', msg]);
+        if (!commit.ok)
+            return null;
+        const hash = parseHash(commit.out);
+        if (!hash)
+            return null;
+        const upd = await gitAsync(gitDir, ['update-ref', `${REF_PREFIX}${ref}`, hash]);
+        if (!upd.ok)
+            return null;
+        // Bound the shadow repo: keep the newest MAX_CHECKPOINTS refs.
+        pruneCheckpoints(cwd);
+        return { ref, time, reason, task: task.slice(0, 80), hash };
     }
     catch {
         return null;

package/dist/agent/loop.js

@@ -146,15 +146,25 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
     // 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;
+    // Snapshot is ASYNC and runs INSIDE runOne (after onToolCall): the tool
+    // card must appear IMMEDIATELY, never behind the snapshot. The old sync
+    // design (spawnSync before onToolCall) froze the TUI for the whole
+    // snapshot — on a big cwd that read as "mentok di Edit" for 40+ seconds
+    // (bench VPS: git add -A pada /root = 41s).
     const maybeCheckpoint = (toolName) => {
         if (checkpointTaken || !MUTATING_TOOLS.has(toolName))
-            return;
+            return Promise.resolve();
         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}`);
-        }
+        return (0, checkpoints_1.takeCheckpointAsync)(cwd, toolName, userRequest)
+            .then((cp) => {
+            if (cp) {
+                callbacks.onStatus?.(`Checkpoint siap (${cp.ref})`);
+                callbacks.onActivity?.('checkpoint', `safety snapshot ${cp.ref}`);
+            }
+        })
+            .catch(() => {
+            /* best-effort — never break the run */
+        });
     };
     const checkAbort = () => {
         if (signal?.aborted) {
@@ -399,7 +409,10 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                 'output_from_background',
             ]);
             const runOne = async (tc) => {
+                // Tool card FIRST (visible instantly), snapshot AFTER — the card
+                // must never wait for the checkpoint git scan.
                 callbacks.onToolCall?.(tc.name, tc.arguments, tc.id);
+                const cpPromise = maybeCheckpoint(tc.name);
                 let toolResult;
                 try {
                     toolResult = await tools.execute(tc.name, tc.arguments, {
@@ -416,6 +429,9 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
                     // as a failed result so the TUI can finalize the card.
                     toolResult = { output: `ERROR: ${err.message}`, summary: 'tool error' };
                 }
+                // The run waits for the (async) safety net before the next model
+                // step, but the tool card above is already visible.
+                await cpPromise;
                 return { tc, toolResult };
             };
             try {
@@ -437,11 +453,9 @@ 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);
+                    // Safety net moved INSIDE runOne (after onToolCall) so the tool
+                    // card renders instantly; armed once per run, lazily. Parallel
+                    // batches are read-only by construction and never trigger it.
                     toolCalls += batch.length;
                     if (!parallel) {
                         callbacks.onStatus?.(`Running ${batch[0].name}`);

package/dist/tools/semantic-search.js

@@ -0,0 +1,276 @@
+"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.createSemanticSearchTools = createSemanticSearchTools;
+/**
+ * Semantic code search — "agent yang hafal codebase" (2026-09-14).
+ *
+ * Alur: chunk file proyek → embedding via GATEWAY relay (/v1/embeddings,
+ * zero-config & zero-key — key provider sk- hidup di gateway, pola sama
+ * dengan e2b.ts/web.ts) → simpan vektor di file lokal (~/.vector/index.json)
+ * → cosine similarity saat query → top-k potongan paling relevan.
+ *
+ * Zero dependency: embedding = HTTP call, similarity = dot product manual,
+ * storage = satu file JSON. Index dibangun manual via tool semantic_index
+ * (atau otomatis saat semantic_search pertama tanpa index).
+ *
+ * Batas wajar (anti-abuse & anti-bloat):
+ * - max file 400 (arg hingga 2000), skip >200KB & file binary-ish
+ * - max chunk 4000; batch embedding 16 input/request; jeda antar-batch
+ *   1.1s (rate limit gateway 60/menit — env VECTOR_EMBED_DELAY_MS utk test)
+ * - skip nama file sensitif (credential/secret/.env/key/pem) — index tidak
+ *   boleh jadi salinan rahasia
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const free_tier_1 = require("../config/free-tier");
+const paths_1 = require("../utils/paths");
+const GW_BASE = free_tier_1.FREE_GATEWAY_URL.replace(/\/v1$/, '');
+const EMBED_URL = GW_BASE + '/v1/embeddings';
+const DEFAULT_EMBED_MODEL = 'text-embedding-v4';
+const IGNORE = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.cache', '.next', 'target', 'coverage', 'sessions', 'logs', 'memory']);
+const TEXT_EXT = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.md', '.py', '.go', '.rs', '.java', '.rb', '.php', '.sh', '.bash', '.yml', '.yaml', '.toml', '.html', '.css', '.scss', '.sql', '.c', '.h', '.cpp', '.hpp', '.cs', '.swift', '.kt', '.txt', '.dockerfile', '.ini', '.cfg']);
+const SENSITIVE = /credential|secret|\.env|\.pem|\.key|id_rsa|password/i;
+const MAX_FILE_BYTES = 200_000;
+const MAX_FILES_DEFAULT = 400;
+const MAX_FILES_HARD = 2000;
+const MAX_CHUNKS = 4000;
+const CHUNK_LINES = 64;
+const BATCH = 16;
+const DELAY_MS = Math.max(0, Number(process.env.VECTOR_EMBED_DELAY_MS ?? 1100));
+function indexPath() {
+    return path.join((0, paths_1.getVectorDir)(), 'index.json');
+}
+function loadIndex() {
+    try {
+        const raw = fs.readFileSync(indexPath(), 'utf8');
+        const j = JSON.parse(raw);
+        return j && j.version === 1 && Array.isArray(j.chunks) ? j : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveIndex(idx) {
+    fs.mkdirSync((0, paths_1.getVectorDir)(), { recursive: true });
+    fs.writeFileSync(indexPath(), JSON.stringify(idx), { mode: 0o600 });
+}
+function walkFiles(dir, out, max) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (out.length >= max)
+            return;
+        if (IGNORE.has(e.name) || e.name.startsWith('.'))
+            continue;
+        if (SENSITIVE.test(e.name))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            walkFiles(full, out, max);
+        else if (TEXT_EXT.has(path.extname(e.name).toLowerCase()) || e.name === 'Dockerfile')
+            out.push(full);
+    }
+}
+function chunkText(content) {
+    const lines = content.split('\n');
+    const chunks = [];
+    for (let i = 0; i < lines.length && chunks.length < MAX_CHUNKS; i += CHUNK_LINES) {
+        const slice = lines.slice(i, i + CHUNK_LINES);
+        const text = slice.join('\n').trim();
+        if (text)
+            chunks.push({ start: i + 1, end: i + slice.length, text });
+    }
+    return chunks;
+}
+async function embed(inputs, model) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 30_000);
+    try {
+        const res = await fetch(EMBED_URL, {
+            method: 'POST',
+            signal: controller.signal,
+            headers: { 'Content-Type': 'application/json', 'User-Agent': 'VectorHead-AI-Agent/0.1' },
+            body: JSON.stringify({ model, input: inputs }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok || !data || !Array.isArray(data.data)) {
+            const snippet = data && data.error ? JSON.stringify(data.error).slice(0, 200) : `HTTP ${res.status}`;
+            throw new Error(`gateway embeddings gagal: ${snippet}`);
+        }
+        // OpenAI format: data[i].embedding — urut by index utk aman.
+        const sorted = [...data.data].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+        return sorted.map((d) => d.embedding);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function cosine(a, b) {
+    let dot = 0, na = 0, nb = 0;
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+}
+async function buildIndex(root, maxFiles) {
+    const files = [];
+    walkFiles(root, files, maxFiles);
+    if (!files.length)
+        return `ERROR: tidak ada file teks yang bisa di-index di ${root}`;
+    const model = DEFAULT_EMBED_MODEL;
+    const chunks = [];
+    for (const full of files) {
+        let content;
+        try {
+            if (fs.statSync(full).size > MAX_FILE_BYTES)
+                continue;
+            content = fs.readFileSync(full, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (content.includes('\u0000'))
+            continue; // binary-ish
+        const rel = path.relative(root, full).split(path.sep).join('/');
+        for (const c of chunkText(content))
+            chunks.push({ file: rel, ...c, embedding: [] });
+    }
+    if (!chunks.length)
+        return 'ERROR: tidak ada chunk yang bisa di-index';
+    for (let i = 0; i < chunks.length; i += BATCH) {
+        const vecs = await embed(chunks.slice(i, i + BATCH).map((c) => c.text), model);
+        if (vecs.length !== Math.min(BATCH, chunks.length - i)) {
+            return `ERROR: jumlah vektor upstream tidak cocok (${vecs.length})`;
+        }
+        vecs.forEach((v, j) => { chunks[i + j].embedding = v; });
+        if (i + BATCH < chunks.length && DELAY_MS)
+            await sleep(DELAY_MS);
+    }
+    saveIndex({ version: 1, model, builtAt: Date.now(), chunks });
+    const preview = [...new Set(chunks.map((c) => c.file))].slice(0, 5).join(', ');
+    return `OK: index dibangun — ${chunks.length} chunk dari ${files.length} file (model ${model}) → ${indexPath()}${preview ? '\nContoh: ' + preview : ''}`;
+}
+function searchIndex(idx, queryVec, k) {
+    const scored = idx.chunks
+        .map((c) => ({ c, score: cosine(queryVec, c.embedding) }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, Math.max(1, k));
+    if (!scored.length || scored[0].score <= 0) {
+        return 'Tidak ada hasil relevan (index kosong / skor 0) — coba semantic_index ulang.';
+    }
+    const lines = scored.map((s, i) => {
+        const head = s.c.text.replace(/\s+/g, ' ').slice(0, 180);
+        return `${i + 1}. ${s.c.file}:${s.c.start}-${s.c.end} (skor ${s.score.toFixed(3)})\n   ${head}`;
+    });
+    return `Hasil semantic search (top ${scored.length} dari ${idx.chunks.length} chunk):\n${lines.join('\n')}`;
+}
+function createSemanticSearchTools() {
+    return [
+        {
+            definition: {
+                name: 'semantic_index',
+                description: 'Build/refresh the local semantic index: embed project files (via the VectorHead gateway, no API key needed) and store vectors in ~/.vector/index.json. Run once per project (or after big changes) — then semantic_search can find code by MEANING, not just keywords.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Directory to index, relative to project root (default ".")' },
+                        max_files: { type: 'number', description: 'Max files to index (default 400, max 2000)' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                const base = path.resolve(ctx.cwd, String(args.path || '.'));
+                const max = Math.min(MAX_FILES_HARD, Math.max(1, Number(args.max_files) || MAX_FILES_DEFAULT));
+                try {
+                    return { output: await buildIndex(base, max) };
+                }
+                catch (e) {
+                    return { output: 'ERROR: ' + String(e.message || e) };
+                }
+            },
+        },
+        {
+            definition: {
+                name: 'semantic_search',
+                description: 'Search the codebase by MEANING (semantic similarity over embedded chunks). Automatically builds the index first if none exists. Use for "where is the retry logic?" style questions where grep/keywords fail.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Natural-language query, e.g. "where do we validate the device id"' },
+                        k: { type: 'number', description: 'Max results (default 5, max 20)' },
+                        path: { type: 'string', description: 'Directory that was indexed (default ".")' },
+                    },
+                    required: ['query'],
+                },
+            },
+            async execute(args, ctx) {
+                const query = String(args.query || '').trim();
+                if (!query)
+                    return { output: 'ERROR: query wajib' };
+                const k = Math.min(20, Math.max(1, Number(args.k) || 5));
+                try {
+                    let idx = loadIndex();
+                    if (!idx) {
+                        const base = path.resolve(ctx.cwd, String(args.path || '.'));
+                        const built = await buildIndex(base, MAX_FILES_DEFAULT);
+                        if (built.startsWith('ERROR'))
+                            return { output: built };
+                        idx = loadIndex();
+                        if (!idx)
+                            return { output: 'ERROR: index gagal dibaca setelah build' };
+                    }
+                    const [qv] = await embed([query], idx.model || DEFAULT_EMBED_MODEL);
+                    if (!qv)
+                        return { output: 'ERROR: embedding query kosong' };
+                    return { output: searchIndex(idx, qv, k) };
+                }
+                catch (e) {
+                    return { output: 'ERROR: ' + String(e.message || e) };
+                }
+            },
+        },
+    ];
+}

package/dist/tui/chat.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOGO_SHEEN_MAX = exports.LOGO_SHEEN_INTERVAL_MS = exports.LOGO_SHEEN_STEP = exports.LOGO_FULL_MIN_COLS = exports.SIDE_GUTTER = exports.mergeStreamDelta = void 0;
+exports.LOGO_SHEEN_MAX = exports.LOGO_SHEEN_INTERVAL_MS = exports.LOGO_SHEEN_STEP = exports.LOGO_FULL_ASCII_MIN_COLS = exports.LOGO_FULL_MIN_COLS = exports.SIDE_GUTTER = exports.mergeStreamDelta = void 0;
 exports.toolIcon = toolIcon;
 exports.toolLabel = toolLabel;
 exports.followupsGroupOf = followupsGroupOf;
@@ -1484,31 +1484,75 @@ function clampScroll(offset, messages, width, height) {
 /**
  * Full-width VECTORHEAD ASCII logo — font "ANSI Shadow", the same figlet
  * font Freebuff uses for its logo (CodebuffAI/freebuff
- * `cli/src/login/constants.ts` LOGO). All 6 rows are exactly 83 columns
- * (letter blocks: V=9 E=8 C=8 T=9 O=9 R=8 H=8 E=8 A=8 D=8) so the art is
+ * `cli/src/login/constants.ts` LOGO). All 6 rows are exactly 56 columns
+ * (letters V=9 E=8 C=8 T=9 O=9 R=8, joined by 1 space) so the art is
  * column-aligned and never wraps. Coloring follows Freebuff's use-logo
  * rules with a VectorHead accent: solid blocks (█) render in `logoBlock`
  * (white), shadow/border box-drawing chars render in orange #FF8534.
+ *
+ * ASCII safe mode (VECTOR_ASCII=1) uses DEDICATED plain-ASCII art instead
+ * (VECTORHEAD_LOGO_ASCII below, figlet "Standard") — squeezing THIS font
+ * 1:1 (█→#, ╔→+) keeps widths exact but destroys the letterforms.
  */
 const VECTORHEAD_LOGO = [
-    '██╗   ██╗███████╗ ██████╗████████╗ ██████╗ ██████╗ ██╗  ██╗███████╗ █████╗ ██████╗ ',
-    '██║   ██║██╔════╝██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗██║  ██║██╔════╝██╔══██╗██╔══██╗',
-    '██║   ██║█████╗  ██║        ██║   ██║   ██║██████╔╝███████║█████╗  ███████║██║  ██║',
-    '╚██╗ ██╔╝██╔══╝  ██║        ██║   ██║   ██║██╔══██╗██╔══██║██╔══╝  ██╔══██║██║  ██║',
-    ' ╚████╔╝ ███████╗╚██████╗   ██║   ╚██████╔╝██║  ██║██║  ██║███████╗██║  ██║██████╔╝',
-    '  ╚═══╝  ╚══════╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═════╝ ',
+    '██╗   ██╗ ███████╗  ██████╗ ████████╗  ██████╗  ██████╗ ',
+    '██║   ██║ ██╔════╝ ██╔════╝ ╚══██╔══╝ ██╔═══██╗ ██╔══██╗',
+    '██║   ██║ █████╗   ██║         ██║    ██║   ██║ ██████╔╝',
+    '╚██╗ ██╔╝ ██╔══╝   ██║         ██║    ██║   ██║ ██╔══██╗',
+    ' ╚████╔╝  ███████╗ ╚██████╗    ██║    ╚██████╔╝ ██║  ██║',
+    '  ╚═══╝   ╚══════╝  ╚═════╝    ╚═╝     ╚═════╝  ╚═╝  ╚═╝',
+];
+/** Minimum terminal width for the full logo (~56 cols + margin). */
+exports.LOGO_FULL_MIN_COLS = 62;
+/** Minimum terminal width for the full ASCII (figlet) logo — 64 cols + margin. */
+exports.LOGO_FULL_ASCII_MIN_COLS = 68;
+/**
+ * Plain-ASCII logo (figlet "Standard") for ASCII safe mode — real ASCII art
+ * designed as art, NOT the block font squeezed char-per-char. All 6 rows
+ * exactly 64 columns; pure \x20-\x7E so it renders 1 column per char on
+ * EVERY font (the whole point of ASCII mode).
+ */
+const VECTORHEAD_LOGO_ASCII = [
+    ' __     _______ ____ _____ ___  ____  _   _ _____    _    ____  ',
+    ' \\ \\   / / ____/ ___|_   _/ _ \\|  _ \\| | | | ____|  / \\  |  _ \\ ',
+    '  \\ \\ / /|  _|| |     | || | | | |_) | |_| |  _|   / _ \\ | | | |',
+    '   \\ V / | |__| |___  | || |_| |  _ <|  _  | |___ / ___ \\| |_| |',
+    '    \\_/  |_____\\____| |_| \\___/|_| \\ \\_| |_|_____/_/   \\ \\____/ ',
+    '                                                                ',
+];
+/** Compact "VE" plain-ASCII logo (figlet "Standard") — 16 cols. */
+const VECTORHEAD_LOGO_SMALL_ASCII = [
+    ' __     _______ ',
+    ' \\ \\   / / ____|',
+    '  \\ \\ / /|  _|  ',
+    '   \\ V / | |___ ',
+    '    \\_/  |_____|',
+    '                ',
 ];
-/** Minimum terminal width for the full logo (~82 cols + margin). */
-exports.LOGO_FULL_MIN_COLS = 84;
-/** Compact "VE" logo (Freebuff LOGO_SMALL tier: first letters, same font;
- *  column starts align across rows — trailing widths vary like Freebuff's). */
+/**
+ * Pick the logo art + its full-tier width threshold for this terminal:
+ * dedicated figlet ASCII art in ASCII safe mode, the ANSI Shadow block
+ * font otherwise (Freebuff-style tiers).
+ */
+function logoArt(width) {
+    if ((0, terminal_1.asciiModeEnabled)()) {
+        return width >= exports.LOGO_FULL_ASCII_MIN_COLS
+            ? { rows: VECTORHEAD_LOGO_ASCII, minCols: exports.LOGO_FULL_ASCII_MIN_COLS }
+            : { rows: VECTORHEAD_LOGO_SMALL_ASCII, minCols: 20 };
+    }
+    return width >= exports.LOGO_FULL_MIN_COLS
+        ? { rows: VECTORHEAD_LOGO, minCols: exports.LOGO_FULL_MIN_COLS }
+        : { rows: VECTORHEAD_LOGO_SMALL, minCols: 20 };
+}
+/** Compact "VE" logo (Freebuff LOGO_SMALL tier: same font, letters joined
+ *  by 1 space — all 6 rows exactly 18 columns, column-aligned). */
 const VECTORHEAD_LOGO_SMALL = [
-    '██╗   ██╗███████╗',
-    '██║   ██║██╔════╝',
-    '██║   ██║█████╗ ',
-    '╚██╗ ██╔╝██╔══╝ ',
-    ' ╚████╔╝███████╗',
-    '  ╚═══╝ ╚══════╝',
+    '██╗   ██╗ ███████╗',
+    '██║   ██║ ██╔════╝',
+    '██║   ██║ █████╗  ',
+    '╚██╗ ██╔╝ ██╔══╝  ',
+    ' ╚████╔╝  ███████╗',
+    '  ╚═══╝   ╚══════╝',
 ];
 /** Shadow/border logo characters — Freebuff SHADOW_CHARS (login/constants.ts). */
 const SHADOW_CHARS = new Set(['╚', '═', '╝', '║', '╔', '╗', '╠', '╣', '╦', '╩', '╬']);
@@ -1540,8 +1584,14 @@ function logoFgFor(char, charIndex, sheen) {
     }
     return theme_1.THEME.textBright;
 }
-/** Paint one logo line with per-character colors (optional sheen sweep). */
+/** Paint one logo line with per-character colors (optional sheen sweep).
+ * Plain-ASCII art rows (no block/shadow glyphs) render single-tone — the
+ * two-tone painting below is defined for the block font only. */
 function paintLogoLine(line, sheen) {
+    if (!/[█║═╔╗╚╝]/.test(line)) {
+        // figlet ASCII art row: understated single-tone brand mark.
+        return `${theme_1.THEME.muted}${line}${theme_1.THEME.reset}`;
+    }
     let out = '';
     let color = '';
     for (let i = 0; i < line.length; i++) {
@@ -1575,9 +1625,10 @@ function paintLogoLine(line, sheen) {
 function buildWelcomeBlock(width, cwd, sheen = null) {
     const lines = [];
     // Freebuff use-logo tiers: full logo when wide, compact logo when medium,
-    // single-line wordmark on very narrow terminals.
-    const logo = width >= exports.LOGO_FULL_MIN_COLS ? VECTORHEAD_LOGO : VECTORHEAD_LOGO_SMALL;
-    if (width >= 20) {
+    // single-line wordmark on very narrow terminals (art picked by logoArt —
+    // dedicated figlet ASCII in ASCII safe mode, block font otherwise).
+    const { rows: logo, minCols } = logoArt(width);
+    if (width >= minCols) {
         for (const l of logo)
             lines.push(paintLogoLine(l, sheen));
     }
@@ -1600,8 +1651,8 @@ function buildWelcomeBlock(width, cwd, sheen = null) {
 function renderWelcome(width, height, cwd, opts = {}) {
     const sheen = opts.sheen ?? null;
     const lines = [];
-    const logo = width >= exports.LOGO_FULL_MIN_COLS ? VECTORHEAD_LOGO : VECTORHEAD_LOGO_SMALL;
-    if (width >= 20) {
+    const { rows: logo, minCols } = logoArt(width);
+    if (width >= minCols) {
         for (const l of logo)
             lines.push(paintLogoLine(l, sheen));
     }

package/package.json

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