agen-vektor 0.3.9 → 0.3.11

package/README.md

@@ -13,7 +13,6 @@
 
 ```
 VectorHead ● Ready                     deepseek-ai/DeepSeek-V4-Flash
-───────────────────────────────────────────────────────────────────────────────
 [09:41]
 Perbaiki error authentication pada project ini
 
@@ -56,13 +55,8 @@ Requirements: **Node.js 20+** and **npm** (Termux: `pkg install nodejs`).
 
 ### From source
 
-```bash
-git clone https://github.com/clickmamaheti-prog/vector-agent.git
-cd vector-agent
-npm install
-npm run build
-npm link          # makes `vector` available on PATH
-```
+Dari source: clone repo ini, lalu `npm install && npm run build && npm link`
+(membuat `vector` tersedia di PATH).
 
 Then:
 

package/dist/agent/agent.js

@@ -16,6 +16,7 @@ const loop_1 = require("./loop");
 const rules_1 = require("./rules");
 const skills_1 = require("./skills");
 const skills_tool_1 = require("../tools/skills-tool");
+const background_1 = require("../tools/background");
 class Agent {
     config;
     provider;
@@ -49,6 +50,9 @@ class Agent {
             (0, apply_patch_1.createApplyPatchTool)(),
             // Hermes-style progressive-disclosure skills (list_skills / read_skill).
             ...(0, skills_tool_1.createSkillTools)(),
+            // Parallelism: non-blocking background shell jobs (run_in_background /
+            // output_from_background / stop_background_job).
+            ...(0, background_1.createBackgroundTools)(),
         ]);
     }
     async run(request, signal) {

package/dist/agent/loop.js

@@ -190,25 +190,68 @@ async function runAgentLoop(userRequest, opts, callbacks = {}) {
             toolCalls: result.toolCalls,
         });
         if (hasToolCalls) {
+            // Parallel execution for READ-ONLY tools (Freebuff-style: when the
+            // model requests several independent reads at once — read_file,
+            // search, glob — run them concurrently instead of one-by-one).
+            // Anything that mutates, prompts for permission, or starts background
+            // work stays sequential so side effects keep their order.
+            const PARALLEL_TOOLS = new Set([
+                'read_file',
+                'list_directory',
+                'search_files',
+                'glob',
+                'read_subtree',
+                'list_skills',
+                'output_from_background',
+            ]);
+            const runOne = async (tc) => {
+                callbacks.onToolCall?.(tc.name, tc.arguments, tc.id);
+                const toolResult = await tools.execute(tc.name, tc.arguments, {
+                    cwd,
+                    permissions,
+                    onActivity: callbacks.onActivity,
+                    maxOutput: 30_000,
+                });
+                return { tc, toolResult };
+            };
             try {
+                const batches = [];
+                let current = [];
                 for (const tc of result.toolCalls) {
+                    if (current.length > 0 && !PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                    current.push(tc);
+                    if (!PARALLEL_TOOLS.has(tc.name)) {
+                        batches.push(current);
+                        current = [];
+                    }
+                }
+                if (current.length > 0)
+                    batches.push(current);
+                for (const batch of batches) {
                     checkAbort();
-                    toolCalls++;
-                    callbacks.onToolCall?.(tc.name, tc.arguments);
-                    callbacks.onStatus?.(`Running ${tc.name}`);
-                    const toolResult = await tools.execute(tc.name, tc.arguments, {
-                        cwd,
-                        permissions,
-                        onActivity: callbacks.onActivity,
-                        maxOutput: 30_000,
-                    });
-                    callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data);
-                    messages.push({
-                        role: 'tool',
-                        toolCallId: tc.id,
-                        name: tc.name,
-                        content: toolResult.output.slice(0, 40_000),
-                    });
+                    const parallel = batch.length > 1 && batch.every((tc) => PARALLEL_TOOLS.has(tc.name));
+                    toolCalls += batch.length;
+                    if (!parallel) {
+                        callbacks.onStatus?.(`Running ${batch[0].name}`);
+                    }
+                    else {
+                        callbacks.onStatus?.(`Running ${batch.length}× ${batch[0].name} (parallel)`);
+                    }
+                    const results = parallel
+                        ? await Promise.all(batch.map(runOne))
+                        : [await runOne(batch[0])];
+                    for (const { tc, toolResult } of results) {
+                        callbacks.onToolResult?.(tc.name, toolResult.output, toolResult.data, tc.id);
+                        messages.push({
+                            role: 'tool',
+                            toolCallId: tc.id,
+                            name: tc.name,
+                            content: toolResult.output.slice(0, 40_000),
+                        });
+                    }
                 }
             }
             catch {

package/dist/agent/prompts.js

@@ -8,6 +8,11 @@ exports.identityPrompt = identityPrompt;
 exports.taskPrompt = taskPrompt;
 exports.continuationPrompt = continuationPrompt;
 exports.SYSTEM_PROMPT = `You are VectorHead, an AI coding agent operating inside a terminal.
+VectorHead is an independent product (npm package "agen-vektor", binary
+"vector", config "~/.vector/") — it is not a fork, port, or rebrand of any
+other agent product. When asked about your identity, version, or origin,
+answer as VectorHead only; never attribute yourself to other agent tools or
+npm packages.
 
 You work autonomously inside the user's project directory. You can:
 - Inspect the project structure and files

package/dist/cli/index.js

@@ -185,7 +185,11 @@ async function runNonInteractive(opts) {
     // answer only arrives in result.content (never via onDelta).
     const reply = result.content.trim();
     if (reply) {
-        process.stdout.write(reply + '\n');
+        // Freebuff appendInterruptionNotice: a user-interrupted run keeps its
+        // partial reply with the marker appended — non-interactive parity.
+        process.stdout.write(result.aborted && !reply.endsWith('[response interrupted]')
+            ? `${reply}\n\n[response interrupted]\n`
+            : reply + '\n');
     }
     else if (result.stopped || result.aborted) {
         console.log(`${terminal_1.ANSI.yellow}⏹ Stopped — no reply was produced.${terminal_1.ANSI.reset}`);

package/dist/config/providers.js

@@ -10,6 +10,7 @@ exports.customProviderPickerOptions = customProviderPickerOptions;
 exports.providerApiKey = providerApiKey;
 exports.isCustomProvider = isCustomProvider;
 exports.providerHeaders = providerHeaders;
+exports.providerBody = providerBody;
 exports.providerConfigured = providerConfigured;
 const credentials_1 = require("./credentials");
 /** Sentinel provider id meaning "add a brand new custom provider". */
@@ -128,6 +129,22 @@ function providerHeaders(config, id) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+/**
+ * Resolve the extra request-body fields for a provider id (OpenCode-style
+ * per-provider options). Returns a shallow copy so callers cannot mutate the
+ * config; undefined when the definition carries no body overrides.
+ */
+function providerBody(config, id) {
+    const raw = customProviderDef(config, id)?.options?.body;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 /**
  * Is a provider fully usable right now? Built-ins need a key (env or stored);
  * a legacy custom needs its apiUrl + key; a named custom needs a base URL in

package/dist/providers/custom.js

@@ -19,6 +19,7 @@ class CustomProvider extends openai_compat_1.OpenAICompatProvider {
             defaultModel: cfg.model || 'default',
             contextWindow: 128000,
             headers: cfg.headers,
+            body: cfg.body,
         });
         this.protocol = cfg.protocol;
     }

package/dist/providers/factory.js

@@ -72,6 +72,7 @@ function createProvider(config) {
                 model: config.model,
                 protocol: config.protocol || 'openai',
                 headers: (0, providers_1.providerHeaders)(config, pid),
+                body: (0, providers_1.providerBody)(config, pid),
             });
         }
     }

package/dist/providers/openai-compat.js

@@ -83,6 +83,8 @@ class OpenAICompatProvider {
     defaultModel;
     contextWindow;
     extraHeaders;
+    /** Provider-level request-body defaults (shallow-copied at construction). */
+    extraBody;
     constructor(opts) {
         this.id = opts.id;
         this.name = opts.name;
@@ -91,6 +93,7 @@ class OpenAICompatProvider {
         this.defaultModel = opts.defaultModel || 'gpt-4o-mini';
         this.contextWindow = opts.contextWindow || 128000;
         this.extraHeaders = opts.headers || {};
+        this.extraBody = { ...(opts.body || {}) };
     }
     capabilities() {
         return {
@@ -136,6 +139,12 @@ class OpenAICompatProvider {
         if (params.tools && params.tools.length > 0) {
             body.tools = toToolDefs(params.tools);
         }
+        // Provider-level body defaults FIRST (options.body — e.g. BitDeer's
+        // reasoning_effort), then the call-level fields on top: an explicit
+        // per-call temperature/max_tokens overrides the provider default.
+        for (const [k, v] of Object.entries(this.extraBody)) {
+            body[k] = v;
+        }
         if (params.temperature !== undefined)
             body.temperature = params.temperature;
         if (params.maxTokens)

package/dist/providers/openrouter.js

@@ -15,7 +15,7 @@ class OpenRouterProvider extends openai_compat_1.OpenAICompatProvider {
     }
     headers() {
         const h = super.headers();
-        h['HTTP-Referer'] = 'https://github.com/clickmamaheti-prog/vector-agent';
+        h['HTTP-Referer'] = 'https://www.npmjs.com/package/agen-vektor';
         h['X-Title'] = 'VectorHead AI Coding Agent';
         return h;
     }

package/dist/tools/apply-patch.js

@@ -170,7 +170,7 @@ function createApplyPatchTool() {
     return {
         definition: {
             name: 'apply_patch',
-            description: 'Apply a patch (unified diff, Freebuff/Codebuff format) to one or more files: "*** Update File: <path>" followed by "@@ -l,c +l,c @@" hunks with lines prefixed by " " (context), "-" (delete), "+" (add); or "*** Delete File: <path>". Creates the file if it does not exist. Safer than full rewrites for small changes. Requires explicit permission.',
+            description: 'Apply a patch (unified diff format) to one or more files: "*** Update File: <path>" followed by "@@ -l,c +l,c @@" hunks with lines prefixed by " " (context), "-" (delete), "+" (add); or "*** Delete File: <path>". Creates the file if it does not exist. Safer than full rewrites for small changes. Requires explicit permission.',
             parameters: {
                 type: 'object',
                 properties: {

package/dist/tools/background.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetBackgroundJobs = resetBackgroundJobs;
+exports.createBackgroundTools = createBackgroundTools;
+/**
+ * Background jobs — long-running shell commands that do NOT block the agent
+ * loop (Freebuff/Codebuff-style parallelism: start a dev server or a long
+ * test suite, keep working, poll the output, stop it when done).
+ *
+ *   run_in_background      → spawn now, return a job id immediately
+ *   output_from_background → status + NEW output since the last poll
+ *   stop_background_job    → SIGKILL the job
+ *
+ * The command goes through the SAME permission policy as the shell tool
+ * (classifyCommand → decide). Jobs live for the lifetime of the process;
+ * output buffers are capped (tail is kept).
+ */
+const node_child_process_1 = require("node:child_process");
+const MAX_LOG = 1_000_000; // keep the TAIL of huge outputs
+const jobs = new Map();
+let nextId = 1;
+/** Test helper: kill everything and reset ids. */
+function resetBackgroundJobs() {
+    for (const job of jobs.values()) {
+        if (job.timeoutTimer)
+            clearTimeout(job.timeoutTimer);
+        killTree(job);
+    }
+    jobs.clear();
+    nextId = 1;
+}
+/** Kill the job's whole process tree — the shell AND its grandchildren. */
+function killTree(job) {
+    const pid = job.child?.pid;
+    if (pid != null) {
+        try {
+            process.kill(-pid, 'SIGKILL'); // detached spawn ⇒ own process group
+        }
+        catch {
+            /* group already gone */
+        }
+    }
+    try {
+        job.child?.kill('SIGKILL');
+    }
+    catch {
+        /* already gone */
+    }
+}
+function trim(job) {
+    if (job.log.length > MAX_LOG) {
+        // keep the tail; shift the cursor so nothing unread is lost
+        const cut = job.log.length - MAX_LOG;
+        job.log = job.log.slice(cut);
+        job.readCursor = Math.max(0, job.readCursor - cut);
+    }
+}
+function describe(job) {
+    const secs = Math.round(((job.endedAt ?? Date.now()) - job.startedAt) / 1000);
+    const status = job.exitCode === null ? `RUNNING (${secs}s)` : job.killed ? `STOPPED after ${secs}s` : `EXITED ${job.exitCode} after ${secs}s`;
+    const fresh = job.log.slice(job.readCursor);
+    job.readCursor = job.log.length;
+    const tail = fresh.length > 20_000 ? `... [${fresh.length - 20_000} chars hidden] ${fresh.slice(-20_000)}` : fresh;
+    return `[${job.id}] ${status} — $ ${job.command}\n${tail || '(no output yet)'}`;
+}
+async function startJob(command, cwd, ctx, timeoutMs) {
+    const level = ctx.permissions.classifyCommand(command);
+    if (level === 'blocked') {
+        return {
+            output: `BLOCKED: command is not permitted by VectorHead security policy:\n${command}`,
+            summary: 'blocked by policy',
+        };
+    }
+    const allowed = await ctx.permissions.decide({ tool: 'shell', summary: `[background] ${command}`, level });
+    if (!allowed) {
+        return { output: `Permission denied by user:\n${command}`, summary: 'denied by user' };
+    }
+    const id = `bg${nextId++}`;
+    const child = (0, node_child_process_1.spawn)(command, {
+        cwd,
+        shell: '/bin/sh',
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true, // own process group → killTree can take down grandchildren
+    });
+    const job = {
+        id,
+        command,
+        child,
+        log: '',
+        readCursor: 0,
+        startedAt: Date.now(),
+        endedAt: null,
+        exitCode: null,
+        killed: false,
+        timeoutTimer: null,
+    };
+    jobs.set(id, job);
+    child.stdout?.on('data', (d) => {
+        job.log += d.toString();
+        trim(job);
+    });
+    child.stderr?.on('data', (d) => {
+        job.log += d.toString();
+        trim(job);
+    });
+    // 'exit' = the shell itself died; 'close' = shell AND stdio pipes closed.
+    // A grandchild (e.g. `sleep`) can hold the pipes open long after the shell
+    // is SIGKILLed, so the final status is recorded on 'exit' — not 'close'.
+    child.on('exit', (code) => {
+        if (job.exitCode === null)
+            job.exitCode = code ?? (job.killed ? -1 : 0);
+        if (job.endedAt === null)
+            job.endedAt = Date.now();
+    });
+    child.on('close', () => {
+        if (job.endedAt === null)
+            job.endedAt = Date.now();
+        job.child = null;
+        if (job.timeoutTimer)
+            clearTimeout(job.timeoutTimer);
+    });
+    child.on('error', (e) => {
+        job.log += `\n[spawn error] ${e.message}`;
+        trim(job);
+        job.exitCode = -1;
+        job.endedAt = Date.now();
+        job.child = null;
+    });
+    if (timeoutMs > 0) {
+        job.timeoutTimer = setTimeout(() => {
+            killTree(job);
+        }, timeoutMs);
+    }
+    return {
+        output: `Started background job ${id}: $ ${command}\nDo NOT wait for it — keep working. Check progress with output_from_background (id: "${id}", or omit for all jobs); stop it with stop_background_job.`,
+        summary: `[bg] started ${id}`,
+        data: { jobId: id },
+    };
+}
+function createBackgroundTools() {
+    return [
+        {
+            definition: {
+                name: 'run_in_background',
+                description: 'Start a shell command in the BACKGROUND and return immediately (non-blocking) — use for dev servers, watchers, long test suites, or anything that runs a while. You get a job id (e.g. bg1); keep working and poll progress with output_from_background, stop with stop_background_job. Do NOT use for quick commands — use shell instead.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'The shell command to run in the background' },
+                        timeout_ms: { type: 'number', description: 'Optional kill-after timeout in ms (0 or omitted = run until stopped)' },
+                    },
+                    required: ['command'],
+                },
+            },
+            async execute(args, ctx) {
+                const command = String(args.command || '').trim();
+                if (!command)
+                    return { output: 'ERROR: empty command' };
+                ctx.onActivity?.('run_in_background', `[bg] $ ${command}`);
+                return startJob(command, ctx.cwd, ctx, Number(args.timeout_ms) || 0);
+            },
+        },
+        {
+            definition: {
+                name: 'output_from_background',
+                description: 'Read the status and NEW output of a background job started with run_in_background (everything since your last poll). Omit "id" to summarize ALL jobs. A RUNNING job may have partial output; EXITED <code> is finished.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Job id from run_in_background (e.g. "bg1"); omit for all jobs' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                ctx.onActivity?.('output_from_background', 'polling background jobs');
+                if (jobs.size === 0)
+                    return { output: 'No background jobs have been started.' };
+                const id = String(args.id || '').trim();
+                if (id) {
+                    const job = jobs.get(id);
+                    if (!job) {
+                        return { output: `ERROR: unknown background job "${id}". Running/known jobs: ${[...jobs.keys()].join(', ') || '(none)'}` };
+                    }
+                    return { output: describe(job), summary: `[bg] poll ${id}`, data: { jobId: id, exitCode: job.exitCode } };
+                }
+                return { output: [...jobs.values()].map((j) => describe(j)).join('\n\n'), summary: `[bg] poll all (${jobs.size})` };
+            },
+        },
+        {
+            definition: {
+                name: 'stop_background_job',
+                description: 'Stop (SIGKILL) a background job started with run_in_background. Use when the server/test/watch is no longer needed or is stuck.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Job id from run_in_background (e.g. "bg1")' },
+                    },
+                    required: ['id'],
+                },
+            },
+            async execute(args, ctx) {
+                const id = String(args.id || '').trim();
+                const job = jobs.get(id);
+                if (!job)
+                    return { output: `ERROR: unknown background job "${id}"` };
+                ctx.onActivity?.('stop_background_job', `stopping ${id}`);
+                job.killed = true;
+                if (job.timeoutTimer)
+                    clearTimeout(job.timeoutTimer);
+                killTree(job);
+                return { output: `Stop signal sent to ${id} ($ ${job.command}). Poll output_from_background for its final output.`, summary: `[bg] stopped ${id}` };
+            },
+        },
+    ];
+}

package/dist/tools/extras.js

@@ -229,7 +229,7 @@ function createExtrasTools() {
         {
             definition: {
                 name: 'task_completed',
-                description: 'Signal that the task is fully done (Freebuff task_completed). Call ONLY after finishing and verifying all requested work. Takes an optional summary with verification results. The TUI shows a checkmark.',
+                description: 'Signal that the task is fully done. Call ONLY after finishing and verifying all requested work. Takes an optional summary with verification results. The TUI shows a checkmark.',
                 parameters: {
                     type: 'object',
                     properties: {
@@ -327,7 +327,7 @@ function createExtrasTools() {
         {
             definition: {
                 name: 'render_ui',
-                description: 'Render an interactive terminal widget (Freebuff render_ui). Currently supports a "button" that opens a URL. Use when giving the user a direct link to click (docs, dashboard, generated report, deployment URL).',
+                description: 'Render an interactive terminal widget. Currently supports a "button" that opens a URL. Use when giving the user a direct link to click (docs, dashboard, generated report, deployment URL).',
                 parameters: {
                     type: 'object',
                     properties: {