kiosapi 0.1.27 → 0.1.29

package/dist/agent/mcp.js

@@ -0,0 +1,205 @@
+/**
+ * MCP (Model Context Protocol) client — stdio transport only.
+ *
+ * Protocol: newline-delimited JSON-RPC 2.0 over child process stdin/stdout.
+ * No external SDK needed — the protocol is simple enough to implement directly.
+ */
+import { spawn } from 'node:child_process';
+import { VERSION } from '../help.js';
+// ---------------------------------------------------------------------------
+// Single server connection
+// ---------------------------------------------------------------------------
+class McpConnection {
+    serverName;
+    proc;
+    buffer = '';
+    pending = new Map();
+    nextId = 1;
+    dead = false;
+    constructor(serverName, config) {
+        this.serverName = serverName;
+        const env = { ...process.env, ...(config.env ?? {}) };
+        // On Windows, npx/npm commands need shell:true to resolve correctly
+        const needsShell = process.platform === 'win32' &&
+            (config.command === 'npx' || config.command === 'npm' || config.command === 'node');
+        this.proc = spawn(config.command, config.args ?? [], {
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'], // capture stderr so it doesn't pollute CLI output
+            shell: needsShell,
+        });
+        this.proc.stdout?.setEncoding('utf8');
+        this.proc.stdout?.on('data', (chunk) => {
+            this.buffer += chunk;
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id !== undefined) {
+                        const p = this.pending.get(msg.id);
+                        if (p) {
+                            clearTimeout(p.timer);
+                            this.pending.delete(msg.id);
+                            if (msg.error) {
+                                p.reject(new Error(msg.error.message));
+                            }
+                            else {
+                                p.resolve(msg.result);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // non-JSON line (debug output, etc.) — ignore
+                }
+            }
+        });
+        const onExit = () => {
+            this.dead = true;
+            for (const p of this.pending.values()) {
+                clearTimeout(p.timer);
+                p.reject(new Error(`MCP server "${this.serverName}" exited unexpectedly`));
+            }
+            this.pending.clear();
+        };
+        this.proc.on('exit', onExit);
+        this.proc.on('error', onExit);
+    }
+    write(msg) {
+        this.proc.stdin?.write(`${JSON.stringify(msg)}\n`);
+    }
+    request(method, params, timeoutMs = 30_000) {
+        return new Promise((resolve, reject) => {
+            if (this.dead) {
+                reject(new Error(`MCP server "${this.serverName}" is not running`));
+                return;
+            }
+            const id = this.nextId++;
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP "${this.serverName}" timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: (r) => resolve(r), reject, timer });
+            this.write({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    async initialize() {
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            clientInfo: { name: 'kiosapi', version: VERSION },
+            capabilities: { tools: {} },
+        }, 10_000);
+        // Notification — no response expected
+        this.write({ jsonrpc: '2.0', method: 'notifications/initialized' });
+    }
+    async listTools() {
+        const result = await this.request('tools/list', {}, 10_000);
+        return result.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', { name, arguments: args }, 60_000);
+        const content = result.content ?? [];
+        const text = content
+            .filter((c) => c.type === 'text' && c.text)
+            .map((c) => c.text ?? '')
+            .join('\n');
+        if (result.isError)
+            throw new Error(`MCP tool error: ${text}`);
+        return text || '(no output)';
+    }
+    kill() {
+        this.dead = true;
+        try {
+            this.proc.kill();
+        }
+        catch {
+            // already dead
+        }
+    }
+    get isAlive() {
+        return !this.dead;
+    }
+}
+// ---------------------------------------------------------------------------
+// Manager: multiple servers, unified tool registry
+// ---------------------------------------------------------------------------
+function sanitizeName(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+export class McpManager {
+    connections = new Map();
+    registry = [];
+    /**
+     * Connect to all configured servers in parallel. Failures are logged but do not abort — a
+     * partially-connected MCP set is better than no MCP at all.
+     */
+    async connect(servers, onWarn) {
+        const entries = Object.entries(servers);
+        const results = await Promise.allSettled(entries.map(async ([name, config]) => {
+            const conn = new McpConnection(name, config);
+            await conn.initialize();
+            const tools = await conn.listTools();
+            this.connections.set(name, conn);
+            for (const tool of tools) {
+                const qualifiedName = `mcp__${sanitizeName(name)}__${sanitizeName(tool.name)}`;
+                this.registry.push({
+                    qualifiedName,
+                    serverName: name,
+                    toolName: tool.name,
+                    spec: {
+                        type: 'function',
+                        function: {
+                            name: qualifiedName,
+                            description: `[MCP:${name}] ${tool.description ?? tool.name}`,
+                            parameters: tool.inputSchema,
+                        },
+                    },
+                });
+            }
+        }));
+        for (const [i, result] of results.entries()) {
+            if (result.status === 'rejected') {
+                const serverName = entries[i]?.[0] ?? '?';
+                onWarn?.(`⚠ MCP server "${serverName}" gagal: ${result.reason.message}`);
+            }
+        }
+    }
+    /** ToolSpec[] for all connected MCP tools — merged into the agent's tool list. */
+    getToolSpecs() {
+        return this.registry.map((r) => r.spec);
+    }
+    /** Dispatch a tool call by qualified name. */
+    async callTool(qualifiedName, args) {
+        const entry = this.registry.find((r) => r.qualifiedName === qualifiedName);
+        if (!entry)
+            throw new Error(`MCP tool "${qualifiedName}" tidak dikenal`);
+        const conn = this.connections.get(entry.serverName);
+        if (!conn?.isAlive)
+            throw new Error(`MCP server "${entry.serverName}" tidak aktif`);
+        return conn.callTool(entry.toolName, args);
+    }
+    get toolCount() {
+        return this.registry.length;
+    }
+    get serverCount() {
+        return this.connections.size;
+    }
+    /** Summary of servers and their tool counts — for display. */
+    summary() {
+        const byServer = new Map();
+        for (const r of this.registry) {
+            if (!byServer.has(r.serverName))
+                byServer.set(r.serverName, []);
+            byServer.get(r.serverName).push(r);
+        }
+        return [...byServer.entries()].map(([server, tools]) => ({ server, tools }));
+    }
+    disconnect() {
+        for (const conn of this.connections.values())
+            conn.kill();
+        this.connections.clear();
+        this.registry = [];
+    }
+}

package/dist/agent/run.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { chatComplete, generateImage, resolveMediaModel, streamVision, } from '../api.js';
-import { CHECKPOINT_PATH } from '../config.js';
+import { CHECKPOINT_PATH, loadMcpServers } from '../config.js';
 import { cyan, dim, green, idn, prompt, red, rupiah, thinking, yellow } from '../ui.js';
+import { McpManager } from './mcp.js';
 import { systemPrompt, toolsForMode } from './schemas.js';
 import { bacaFile, cari, daftarFile, editFile, hapusFile, jalankan, pindahFile, safePath, tulisFile, } from './tools.js';
 const MAX_STEPS = 50;
@@ -56,32 +57,47 @@ function trimContext(messages) {
     const dropped = clean.length - tail.length;
     if (dropped <= 0)
         return [system, ...clean];
-    // Collect baca_file paths from the dropped messages so the model knows which files it
-    // already has context for — prevents it from re-orienting by re-reading config/schema files.
+    // Collect baca_file and daftar_file calls from the dropped messages so the model knows which
+    // files/directories it already has context for — prevents re-orientation loops after trimming.
     const droppedHead = clean.slice(0, clean.length - tail.length + skip);
     const droppedPaths = [];
+    const droppedDirs = [];
+    const droppedModified = [];
     for (const msg of droppedHead) {
         if (msg.role === 'assistant' && msg.tool_calls) {
             for (const tc of msg.tool_calls) {
-                if (tc.function?.name === 'baca_file') {
-                    try {
-                        const a = JSON.parse(tc.function.arguments ?? '{}');
-                        if (a.path)
-                            droppedPaths.push(a.path);
-                    }
-                    catch {
-                        /* ignore */
-                    }
+                try {
+                    const a = JSON.parse(tc.function.arguments ?? '{}');
+                    if (tc.function?.name === 'baca_file' && a.path)
+                        droppedPaths.push(a.path);
+                    if (tc.function?.name === 'daftar_file')
+                        droppedDirs.push(a.path || '.');
+                }
+                catch {
+                    /* ignore */
                 }
             }
         }
+        // Track files that were successfully written/edited/deleted in the dropped context so the
+        // model knows it already made those changes and shouldn't repeat them after trimming.
+        if (msg.role === 'tool' && msg.content) {
+            const m = msg.content.match(/^OK:\s+(.+?)\s+(dibuat|diubah|dihapus|dipindah)/);
+            if (m?.[1])
+                droppedModified.push(m[1]);
+        }
     }
     const filesNote = droppedPaths.length > 0
-        ? ` File sudah dibaca (tak lagi di window): ${[...new Set(droppedPaths)].join(', ')}. JANGAN baca ulang — gunakan cari untuk mencari teks spesifik.`
+        ? ` File sudah dibaca: ${[...new Set(droppedPaths)].join(', ')}. JANGAN baca ulang — gunakan cari untuk teks spesifik.`
+        : '';
+    const dirsNote = droppedDirs.length > 0
+        ? ` Direktori sudah terdaftar: ${[...new Set(droppedDirs)].join(', ')}. JANGAN list ulang — gunakan baca_file untuk file spesifik.`
+        : '';
+    const modifiedNote = droppedModified.length > 0
+        ? ` File sudah dimodifikasi: ${[...new Set(droppedModified)].join(', ')}. JANGAN tulis ulang kecuali ada perubahan tambahan.`
         : '';
     const note = {
         role: 'system',
-        content: `[Kiosapi: ${dropped} pesan awal dihapus dari konteks.${filesNote}]`,
+        content: `[Kiosapi: ${dropped} pesan awal dihapus dari konteks.${filesNote}${dirsNote}${modifiedNote}]`,
     };
     return [system, note, ...tail];
 }
@@ -472,7 +488,8 @@ export async function runTurn(s, userText) {
         }
     }
     s.messages.push({ role: 'user', content: userText });
-    const tools = toolsForMode(s.mode);
+    s._lastCompleted = false;
+    const tools = [...toolsForMode(s.mode), ...(s.mcpManager?.getToolSpecs() ?? [])];
     let lastText = '';
     let totalIn = 0;
     let totalOut = 0;
@@ -482,12 +499,15 @@ export async function runTurn(s, userText) {
         }
     };
     // Loop detection: count total calls per signature (tool+args) across the whole runTurn.
-    // Consecutive-3 catches obvious tight loops; count-4 catches spread-out repetition where
-    // other calls (daftar src, baca ...) appear between the repeating call.
+    // Consecutive-3 catches obvious tight loops; count-N catches spread-out repetition.
+    // daftar_file has a lower limit (3) because re-listing the same directory is almost never
+    // useful; baca_file legitimately needs more chances (range reads + post-edit re-reads).
     const callCounts = new Map();
     const lastSigs = []; // last 3 sigs for consecutive detection
-    const COUNT_LIMIT = 6; // same tool+args called 6× total → loop (higher because cache now returns content)
+    const COUNT_LIMITS = { daftar_file: 3, cari: 4 };
+    const DEFAULT_COUNT_LIMIT = 6;
     const CONSEC_LIMIT = 3; // same sig 3× in a row → loop
+    const countLimitFor = (toolName) => COUNT_LIMITS[toolName] ?? DEFAULT_COUNT_LIMIT;
     // Read-only tool cache: on 2nd+ identical call, return the previous result with a warning
     // instead of re-running. This gives the model early feedback so it can self-correct before
     // COUNT_LIMIT is reached, preventing the common "list root, list root, list root" pattern.
@@ -553,9 +573,9 @@ export async function runTurn(s, userText) {
             lastSigs.push(sig);
             if (lastSigs.length > CONSEC_LIMIT)
                 lastSigs.shift();
-            // Total count exceeded, or 3 in a row
+            // Total count exceeded (per-tool limit), or 3 in a row
             const consecutive = lastSigs.length === CONSEC_LIMIT && lastSigs.every((s) => s === sig);
-            if (count >= COUNT_LIMIT || consecutive) {
+            if (count >= countLimitFor(call.function.name) || consecutive) {
                 loopSig = sig;
                 break;
             }
@@ -565,7 +585,14 @@ export async function runTurn(s, userText) {
             const total = callCounts.get(loopSig) ?? 0;
             console.log(red(`\n⚠ Loop terdeteksi: "${loopName}" dipanggil ${total}× — agen terjebak.`));
             console.log(yellow('Berikan instruksi baru, atau ketik /bersih untuk mulai ulang.'));
-            const loopMsg = `⚠ LOOP: "${loopName}" sudah dipanggil ${total}× dengan argumen yang sama. JANGAN panggil lagi. Gunakan tool "selesai" dan jelaskan kendalanya, atau minta klarifikasi dari pengguna.`;
+            const loopMsg = `⚠ LOOP TERDETEKSI: "${loopName}" sudah dipanggil ${total}× — BERHENTI SEKARANG.
+
+Panggil tool "selesai" dengan ringkasan yang berisi:
+1. Apa yang SUDAH berhasil dikerjakan (file diubah, perintah dijalankan)
+2. Apa yang BELUM selesai dan kendala yang ditemui
+3. Saran langkah berikutnya untuk pengguna
+
+JANGAN panggil tool lain selain "selesai".`;
             for (const call of calls) {
                 s.messages.push({ role: 'tool', content: loopMsg, tool_call_id: call.id });
             }
@@ -588,9 +615,13 @@ export async function runTurn(s, userText) {
                 // trimContext drops old messages from its window. The escalating warning text
                 // discourages repetition; withholding the content at count=3+ only causes the model
                 // to keep retrying — counter-productive to stopping the loop.
-                const stopNote = count >= COUNT_LIMIT - 1
-                    ? `\n\n⚠ STOP (ke-${count}): JANGAN panggil "${toolName}" lagi dengan argumen yang sama. Gunakan tool "selesai" dan jelaskan kendalanya, atau gunakan cari/baca_file dengan path/range BERBEDA.`
-                    : `\n\n⚠ Cache ke-${count}: "${toolName}" sudah dipanggil ${count}× dengan argumen sama. Gunakan cari atau baca_file(path, mulai=N) untuk bagian berbeda.`;
+                const toolLimit = countLimitFor(toolName);
+                const isLastChance = count >= toolLimit - 1;
+                const stopNote = isLastChance
+                    ? `\n\n⚠ STOP (ke-${count}/${toolLimit}): JANGAN panggil "${toolName}" lagi dengan argumen yang sama. Gunakan tool "selesai" dan jelaskan kendalanya, atau gunakan cari/baca_file dengan path/range BERBEDA.`
+                    : toolName === 'daftar_file'
+                        ? `\n\n⚠ Cache ke-${count}: direktori ini SUDAH terdaftar. JANGAN list ulang — gunakan baca_file(path) untuk file spesifik di dalamnya.`
+                        : `\n\n⚠ Cache ke-${count}: "${toolName}" sudah dipanggil ${count}× dengan argumen sama. Gunakan cari atau baca_file(path, mulai=N) untuk bagian berbeda.`;
                 const warn = `[Cache ke-${count}]\n${cachedOut}${stopNote}`;
                 const cachePathHint = (() => {
                     try {
@@ -604,6 +635,45 @@ export async function runTurn(s, userText) {
                 s.messages.push({ role: 'tool', content: warn, tool_call_id: call.id });
                 continue;
             }
+            // MCP tool dispatch — routed to the connected MCP server
+            if (call.function.name.startsWith('mcp__') && s.mcpManager) {
+                let mcpArgs = {};
+                try {
+                    mcpArgs = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    s.messages.push({
+                        role: 'tool',
+                        content: 'Error: argumen bukan JSON valid.',
+                        tool_call_id: call.id,
+                    });
+                    continue;
+                }
+                const [, serverPart, ...toolParts] = call.function.name.split('__');
+                console.log(dim(`  mcp:${serverPart} → ${toolParts.join('__')}`));
+                if (!(await allow(s.otomatis, `Jalankan MCP tool "${call.function.name}"?`))) {
+                    s.messages.push({
+                        role: 'tool',
+                        content: 'Ditolak oleh pengguna.',
+                        tool_call_id: call.id,
+                    });
+                    continue;
+                }
+                let mcpOut;
+                try {
+                    mcpOut = await s.mcpManager.callTool(call.function.name, mcpArgs);
+                }
+                catch (err) {
+                    mcpOut = `Error MCP: ${err instanceof Error ? err.message : String(err)}`;
+                }
+                const MAX_STORED_RESULT_MCP = 10_000;
+                const stored = mcpOut.length > MAX_STORED_RESULT_MCP
+                    ? `${mcpOut.slice(0, MAX_STORED_RESULT_MCP)}\n…[dipotong]`
+                    : mcpOut;
+                s.messages.push({ role: 'tool', content: stored, tool_call_id: call.id });
+                saveCheckpoint(s);
+                continue;
+            }
             const result = await runTool(call, s.otomatis, s.model);
             // Cap what goes into the conversation history: full output can be 300 lines of directory
             // listing or 100 KB of file content, which quickly overflows small-context-window models
@@ -633,6 +703,7 @@ export async function runTurn(s, userText) {
                 console.log(green(`\n✓ Selesai: ${result.output}`));
                 showUsage();
                 s.totalTokens += totalIn + totalOut;
+                s._lastCompleted = true;
                 clearCheckpoint();
                 return result.output;
             }
@@ -651,5 +722,19 @@ export async function runTurn(s, userText) {
 }
 /** One-shot: run a single task in a mode (used by the `rencana`/`edit`/`buat` subcommands). */
 export async function runAgent(task, mode, opts) {
-    await runTurn(newSession(opts.model, mode, opts.otomatis), task);
+    const s = newSession(opts.model, mode, opts.otomatis);
+    const mcpServers = loadMcpServers();
+    let mcpManager;
+    if (Object.keys(mcpServers).length > 0) {
+        mcpManager = new McpManager();
+        await mcpManager.connect(mcpServers);
+        if (mcpManager.toolCount > 0)
+            s.mcpManager = mcpManager;
+    }
+    try {
+        await runTurn(s, task);
+    }
+    finally {
+        mcpManager?.disconnect();
+    }
 }

package/dist/agent/skills.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { SKILLS_GLOBAL_DIR, projectSkillsDir } from '../config.js';
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return { meta: {}, body: content.trim() };
+    const end = content.indexOf('\n---\n', 4);
+    if (end === -1)
+        return { meta: {}, body: content.trim() };
+    const raw = content.slice(4, end);
+    const meta = {};
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#'))
+            continue;
+        const match = trimmed.match(/^(\w+):\s*(.*)$/);
+        if (match?.[1])
+            meta[match[1]] = match[2]?.trim() ?? '';
+    }
+    return { meta, body: content.slice(end + 5).trim() };
+}
+function readSkillFile(filePath, source) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const { meta, body } = parseFrontmatter(content);
+        const name = filePath.split(/[/\\]/).pop()?.replace(/\.md$/, '') ?? '';
+        if (!name || !body)
+            return null;
+        const modeRaw = meta.mode ?? 'buat';
+        const mode = modeRaw === 'rencana' || modeRaw === 'edit' ? modeRaw : 'buat';
+        return {
+            name,
+            description: meta.description ?? '',
+            prompt: body,
+            mode,
+            otomatis: meta.otomatis === 'true',
+            model: meta.model || undefined,
+            source,
+            filePath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Load a skill by name: project (.kiosapi/skills/) overrides global (~/.kiosapi/skills/). */
+export function loadSkill(name) {
+    const projectPath = join(projectSkillsDir(), `${name}.md`);
+    if (existsSync(projectPath))
+        return readSkillFile(projectPath, 'project');
+    const globalPath = join(SKILLS_GLOBAL_DIR, `${name}.md`);
+    if (existsSync(globalPath))
+        return readSkillFile(globalPath, 'global');
+    return null;
+}
+/** List all available skills (project overrides global on name collision). */
+export function listSkills() {
+    const skills = new Map();
+    // Load global first so project can override
+    for (const { dir, source } of [
+        { dir: SKILLS_GLOBAL_DIR, source: 'global' },
+        { dir: projectSkillsDir(), source: 'project' },
+    ]) {
+        if (!existsSync(dir))
+            continue;
+        try {
+            for (const file of readdirSync(dir)) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const sk = readSkillFile(join(dir, file), source);
+                if (sk)
+                    skills.set(sk.name, sk);
+            }
+        }
+        catch {
+            /* unreadable dir — ignore */
+        }
+    }
+    return [...skills.values()].sort((a, b) => {
+        if (a.source !== b.source)
+            return a.source === 'project' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}