blyuecode 0.1.9 → 0.1.10

package/dist/core/agent.js

@@ -1,30 +1,54 @@
 import { Provider } from './provider.js';
 import { getToolDefs, executeTool } from './tools.js';
+import { loadSession, saveSession, clearSession } from './session.js';
+const SYSTEM_PROMPT = 'You are BLYUE, a coding assistant running in a terminal. ' +
+    'Use tools to read, write, and run commands. ' +
+    'If n8n tools are available, you can also manage n8n workflows. ' +
+    'Always explain what you are doing. Be concise.';
 export class Agent {
     provider = null;
+    messages;
+    constructor(resume = true) {
+        const sys = { role: 'system', content: SYSTEM_PROMPT };
+        const history = resume ? loadSession() : null;
+        if (history && history.length > 0) {
+            this.messages = [sys, ...history];
+        }
+        else {
+            this.messages = [sys];
+        }
+    }
     getProvider() {
         if (!this.provider)
             this.provider = new Provider();
         return this.provider;
     }
-    messages = [
-        {
-            role: 'system',
-            content: 'You are BLYUE, a coding assistant running in a terminal. ' +
-                'Use tools to read, write, and run commands. ' +
-                'If n8n tools are available, you can also manage n8n workflows. ' +
-                'Always explain what you are doing. Be concise.',
-        },
-    ];
+    persist() {
+        try {
+            saveSession(this.messages.slice(1)); // skip system prompt
+        }
+        catch { }
+    }
+    historySize() {
+        return this.messages.length - 1;
+    }
+    clear() {
+        this.messages = [{ role: 'system', content: SYSTEM_PROMPT }];
+        clearSession();
+    }
     async *run(userInput) {
         this.messages.push({ role: 'user', content: userInput });
+        this.persist();
         while (true) {
             const tools = getToolDefs();
             const res = await this.getProvider().chat(this.messages, tools);
-            if (res.content)
+            if (res.content) {
                 yield res.content;
-            if (res.toolCalls.length === 0)
+            }
+            if (res.toolCalls.length === 0) {
+                this.persist();
                 break;
+            }
             this.messages.push({
                 role: 'assistant',
                 content: res.content,
@@ -50,6 +74,7 @@ export class Agent {
                 const preview = result.length > 500 ? result.slice(0, 500) + '...' : result;
                 yield '[Result]: ' + preview + '\n';
             }
+            this.persist();
         }
     }
 }

package/dist/core/diff.js

@@ -0,0 +1,63 @@
+// Simple LCS-based line diff. Good enough for previews.
+export function lineDiff(oldText, newText) {
+    const a = oldText.length ? oldText.split('\n') : [];
+    const b = newText.length ? newText.split('\n') : [];
+    const m = a.length;
+    const n = b.length;
+    // LCS table
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (a[i] === b[j])
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            else
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            out.push({ type: 'same', text: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push({ type: 'remove', text: a[i] });
+            i++;
+        }
+        else {
+            out.push({ type: 'add', text: b[j] });
+            j++;
+        }
+    }
+    while (i < m)
+        out.push({ type: 'remove', text: a[i++] });
+    while (j < n)
+        out.push({ type: 'add', text: b[j++] });
+    return out;
+}
+// Compact display: only show changed regions with context
+export function compactDiff(diff, context = 2) {
+    const keep = new Set();
+    diff.forEach((d, idx) => {
+        if (d.type !== 'same') {
+            for (let k = Math.max(0, idx - context); k <= Math.min(diff.length - 1, idx + context); k++) {
+                keep.add(k);
+            }
+        }
+    });
+    const out = [];
+    let lastKept = -1;
+    for (let i = 0; i < diff.length; i++) {
+        if (keep.has(i)) {
+            if (lastKept !== -1 && i > lastKept + 1) {
+                out.push({ type: 'same', text: '…' });
+            }
+            out.push(diff[i]);
+            lastKept = i;
+        }
+    }
+    return out;
+}

package/dist/core/permission.js

@@ -0,0 +1,44 @@
+class PermissionBroker {
+    pending = null;
+    // Session-scoped "always allow" set (cleared on restart)
+    alwaysAllow = new Set();
+    listeners = new Set();
+    nextId = 0;
+    subscribe(fn) {
+        this.listeners.add(fn);
+        // Immediately notify with current state
+        fn(this.pending?.req ?? null);
+        return () => this.listeners.delete(fn);
+    }
+    notify(req) {
+        for (const fn of this.listeners)
+            fn(req);
+    }
+    isAlwaysAllowed(tool) {
+        return this.alwaysAllow.has(tool);
+    }
+    async ask(req) {
+        if (this.alwaysAllow.has(req.tool))
+            return 'yes';
+        const id = `p${++this.nextId}`;
+        const full = { ...req, id };
+        return new Promise((resolve) => {
+            this.pending = { req: full, resolve };
+            this.notify(full);
+        });
+    }
+    answer(a) {
+        if (!this.pending)
+            return;
+        const { req, resolve } = this.pending;
+        if (a === 'always')
+            this.alwaysAllow.add(req.tool);
+        this.pending = null;
+        this.notify(null);
+        resolve(a);
+    }
+    resetSession() {
+        this.alwaysAllow.clear();
+    }
+}
+export const permissions = new PermissionBroker();

package/dist/core/session.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+const SESSIONS_DIR = path.join(os.homedir(), '.blyue', 'sessions');
+export function sessionFile(cwd = process.cwd()) {
+    if (!fs.existsSync(SESSIONS_DIR))
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    const hash = crypto.createHash('sha1').update(cwd).digest('hex').slice(0, 12);
+    return path.join(SESSIONS_DIR, `${hash}.json`);
+}
+export function loadSession(cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return data.messages || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSession(messages, cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    const data = {
+        project: cwd,
+        updatedAt: Date.now(),
+        messages,
+    };
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+export function clearSession(cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    if (fs.existsSync(file))
+        fs.unlinkSync(file);
+}
+export function listSessions() {
+    if (!fs.existsSync(SESSIONS_DIR))
+        return [];
+    const out = [];
+    for (const f of fs.readdirSync(SESSIONS_DIR)) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf8'));
+            out.push({
+                file: f,
+                project: data.project,
+                updatedAt: data.updatedAt,
+                count: data.messages.length,
+            });
+        }
+        catch { }
+    }
+    return out.sort((a, b) => b.updatedAt - a.updatedAt);
+}

package/dist/core/tools.js

@@ -1,10 +1,12 @@
 import fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { hasN8n } from './config.js';
+import { permissions } from './permission.js';
+import { lineDiff, compactDiff } from './diff.js';
 import { n8nListWorkflows, n8nTriggerWorkflow, n8nListExecutions, n8nGetWorkflow, n8nActivateWorkflow, n8nDeactivateWorkflow, } from './n8n.js';
 const execAsync = promisify(exec);
-// Base tools — always available
 const BASE_TOOLS = [
     {
         type: 'function',
@@ -57,105 +59,96 @@ const BASE_TOOLS = [
         },
     },
 ];
-// n8n tools — only loaded when N8N_URL + N8N_API_KEY are set
 const N8N_TOOLS = [
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_list_workflows',
-            description: 'List all n8n workflows. Returns id, name, active status, updatedAt.',
-            parameters: { type: 'object', properties: {} },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_get_workflow',
-            description: 'Get details of a specific n8n workflow by ID',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_trigger_workflow',
-            description: 'Trigger an n8n workflow via its webhook URL',
-            parameters: {
-                type: 'object',
-                properties: {
-                    workflowId: { type: 'string' },
-                    data: { type: 'object' },
-                },
-                required: ['workflowId'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_list_executions',
-            description: 'List recent n8n executions (runs)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    workflowId: { type: 'string' },
-                    limit: { type: 'number' },
-                },
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_activate_workflow',
-            description: 'Activate an n8n workflow',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_deactivate_workflow',
-            description: 'Deactivate an n8n workflow',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
+    { type: 'function', function: { name: 'n8n_list_workflows', description: 'List n8n workflows', parameters: { type: 'object', properties: {} } } },
+    { type: 'function', function: { name: 'n8n_get_workflow', description: 'Get n8n workflow by ID', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
+    { type: 'function', function: { name: 'n8n_trigger_workflow', description: 'Trigger n8n workflow', parameters: { type: 'object', properties: { workflowId: { type: 'string' }, data: { type: 'object' } }, required: ['workflowId'] } } },
+    { type: 'function', function: { name: 'n8n_list_executions', description: 'List n8n executions', parameters: { type: 'object', properties: { workflowId: { type: 'string' }, limit: { type: 'number' } } } } },
+    { type: 'function', function: { name: 'n8n_activate_workflow', description: 'Activate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
+    { type: 'function', function: { name: 'n8n_deactivate_workflow', description: 'Deactivate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
 ];
-// Dynamic — includes n8n tools only if configured
 export function getToolDefs() {
     return hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
 }
-// For backwards compat if anything imports toolDefs directly
 export const toolDefs = BASE_TOOLS;
+// Dangerous command patterns
+const DANGER_PATTERNS = [
+    { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)?/, level: 'high' },
+    { re: /\bsudo\b/, level: 'high' },
+    { re: /\bmkfs\b|\bdd\s+if=/, level: 'high' },
+    { re: />\s*\/dev\//, level: 'high' },
+    { re: /:\(\)\s*\{/, level: 'high' }, // fork bomb
+    { re: /\bchmod\s+(-R\s+)?777\b/, level: 'medium' },
+    { re: /\bgit\s+push\b/, level: 'medium' },
+    { re: /\bnpm\s+(publish|unpublish)\b/, level: 'medium' },
+    { re: /\bcurl\b.*\|\s*(sh|bash)\b/, level: 'high' },
+];
+function classify(cmd) {
+    for (const { re, level } of DANGER_PATTERNS) {
+        if (re.test(cmd))
+            return level;
+    }
+    return 'low';
+}
 export async function executeTool(name, args) {
     try {
         switch (name) {
             case 'read_file':
                 return await fs.readFile(args.path, 'utf8');
-            case 'write_file':
-                await fs.writeFile(args.path, args.content, 'utf8');
-                return 'Wrote ' + args.path;
+            case 'write_file': {
+                const path = args.path;
+                const content = args.content;
+                const existed = existsSync(path);
+                let oldText = '';
+                if (existed) {
+                    try {
+                        oldText = readFileSync(path, 'utf8');
+                    }
+                    catch { }
+                }
+                if (!permissions.isAlwaysAllowed('write_file')) {
+                    const lines = content.split('\n');
+                    const body = [
+                        existed ? `Overwrite ${path}` : `Create ${path}`,
+                        `${lines.length} lines · ${content.length} bytes`,
+                    ];
+                    let diffPreview;
+                    if (existed && oldText !== content) {
+                        const d = compactDiff(lineDiff(oldText, content), 2);
+                        diffPreview = d.slice(0, 60);
+                    }
+                    const answer = await permissions.ask({
+                        tool: 'write_file',
+                        title: existed ? 'Write file' : 'Create file',
+                        body,
+                        diff: diffPreview,
+                        danger: existed ? 'medium' : 'low',
+                    });
+                    if (answer === 'no')
+                        return `Denied by user: write_file ${path}`;
+                }
+                await fs.writeFile(path, content, 'utf8');
+                return 'Wrote ' + path;
+            }
             case 'list_files': {
                 const dir = args.path || '.';
                 const entries = await fs.readdir(dir, { withFileTypes: true });
-                return entries
-                    .map((e) => (e.isDirectory() ? e.name + '/' : e.name))
-                    .join('\n');
+                return entries.map((e) => (e.isDirectory() ? e.name + '/' : e.name)).join('\n');
             }
             case 'run_command': {
-                const { stdout, stderr } = await execAsync(args.command, {
+                const cmd = args.command;
+                if (!permissions.isAlwaysAllowed('run_command')) {
+                    const danger = classify(cmd);
+                    const answer = await permissions.ask({
+                        tool: 'run_command',
+                        title: 'Run command',
+                        body: ['$ ' + cmd, `cwd: ${process.cwd()}`, `risk: ${danger}`],
+                        danger,
+                    });
+                    if (answer === 'no')
+                        return `Denied by user: run_command`;
+                }
+                const { stdout, stderr } = await execAsync(cmd, {
                     cwd: process.cwd(),
                     maxBuffer: 10 * 1024 * 1024,
                 });

package/dist/index.js

@@ -6,20 +6,22 @@ import { Setup } from './ui/Setup.js';
 import { Chat } from './ui/Chat.js';
 import { Banner } from './ui/Banner.js';
 import { loadConfig, applyConfig } from './core/config.js';
+import { loadSession } from './core/session.js';
 const App = () => {
     const [ready, setReady] = useState(false);
+    const [resumedCount, setResumedCount] = useState(0);
     useEffect(() => {
         const existing = loadConfig();
         if (existing) {
             applyConfig(existing);
+            const hist = loadSession();
+            setResumedCount(hist ? hist.length : 0);
             setReady(true);
         }
     }, []);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Static, { items: ['banner'], children: () => _jsx(Banner, {}) }), ready ? _jsx(Chat, {}) : _jsx(Setup, { onDone: () => setReady(true) })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Static, { items: ['banner'], children: () => _jsx(Banner, {}) }), ready ? (_jsx(Chat, { resumedCount: resumedCount })) : (_jsx(Setup, { onDone: () => setReady(true) }))] }));
 };
 render(_jsx(App, {}), {
-    // Prevent console.log interference from npm/openai warnings
     patchConsole: false,
-    // Only redraw when Ink state actually changes
     exitOnCtrlC: true,
 });

package/dist/ui/Chat.js

@@ -1,17 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput, useStdout, Static } from 'ink';
 import { Agent } from '../core/agent.js';
+import { permissions } from '../core/permission.js';
 import { InputBar } from './InputBar.js';
 import { ModelPicker } from './ModelPicker.js';
 import { Settings } from './Settings.js';
+import { PermissionPrompt } from './PermissionPrompt.js';
 import { theme } from './theme.js';
 let nextId = 0;
-const mkItem = (kind, text) => ({
-    kind,
-    text,
-    id: nextId++,
-});
+const mkItem = (kind, text) => ({ kind, text, id: nextId++ });
 const HistoryLine = ({ item }) => {
     if (item.kind === 'user') {
         return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: '❯ ' }), _jsx(Text, { color: theme.text, bold: true, children: item.text })] }));
@@ -24,16 +22,29 @@ const HistoryLine = ({ item }) => {
     }
     return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text, children: item.text }) }));
 };
-export const Chat = () => {
+export const Chat = ({ resumedCount = 0 }) => {
     const { stdout } = useStdout();
     const width = stdout?.columns ?? 80;
-    const [history, setHistory] = useState([]);
+    const [history, setHistory] = useState(() => {
+        if (resumedCount > 0) {
+            return [mkItem('tool', `(resumed session · ${resumedCount} prior messages)`)];
+        }
+        return [];
+    });
     const [input, setInput] = useState('');
     const [loading, setLoading] = useState(false);
     const [overlay, setOverlay] = useState('none');
+    const [permReq, setPermReq] = useState(null);
     const [currentModel, setCurrentModel] = useState(process.env.MODEL || '');
     const [agent, setAgent] = useState(() => new Agent());
+    // Subscribe to permission requests
+    useEffect(() => {
+        const unsub = permissions.subscribe((req) => setPermReq(req));
+        return unsub;
+    }, []);
     useInput((inputChar, key) => {
+        if (permReq)
+            return; // permission prompt handles its own input
         if (key.ctrl && inputChar === 'p')
             setOverlay('model');
         if (key.ctrl && inputChar === 's')
@@ -53,13 +64,21 @@ export const Chat = () => {
             setOverlay('settings');
             return;
         }
+        if (trimmed === '/clear') {
+            setInput('');
+            agent.clear();
+            permissions.resetSession();
+            setHistory([mkItem('tool', '(conversation cleared)')]);
+            return;
+        }
         if (trimmed === '/help') {
             setInput('');
             setHistory((h) => [
                 ...h,
                 mkItem('tool', 'Commands:'),
-                mkItem('tool', '  /model     switch model        (Ctrl+P)'),
-                mkItem('tool', '  /settings  open settings       (Ctrl+S)'),
+                mkItem('tool', '  /model     switch model          (Ctrl+P)'),
+                mkItem('tool', '  /settings  open settings         (Ctrl+S)'),
+                mkItem('tool', '  /clear     clear session and permissions'),
                 mkItem('tool', '  /help      show this list'),
             ]);
             return;
@@ -85,6 +104,10 @@ export const Chat = () => {
         setAgent(new Agent());
         setHistory((h) => [...h, mkItem('tool', `model → ${id}`)]);
     };
+    // Permission prompt takes priority over everything
+    if (permReq) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (item) => _jsx(HistoryLine, { item: item }, item.id) }), _jsx(Box, { marginTop: 1, children: _jsx(PermissionPrompt, { req: permReq }) })] }));
+    }
     if (overlay === 'model') {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(ModelPicker, { current: currentModel, onSelect: handleModelSelect, onCancel: () => setOverlay('none') }) }));
     }

package/dist/ui/PermissionPrompt.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useInput, useStdout } from 'ink';
+import { permissions } from '../core/permission.js';
+import { theme } from './theme.js';
+export const PermissionPrompt = ({ req }) => {
+    const { stdout } = useStdout();
+    const width = Math.max(40, stdout?.columns ?? 60);
+    const inner = width - 4;
+    useInput((input, key) => {
+        if (input === 'y' || input === 'Y')
+            permissions.answer('yes');
+        else if (input === 'n' || input === 'N' || key.escape)
+            permissions.answer('no');
+        else if (input === 'a' || input === 'A')
+            permissions.answer('always');
+    });
+    const dangerColor = req.danger === 'high' ? theme.error :
+        req.danger === 'medium' ? theme.warning :
+            theme.accent;
+    const title = `${req.danger === 'high' ? '⚠  ' : ''}${req.title}`;
+    const topPad = Math.max(1, inner - title.length - 3);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: dangerColor, bold: true, children: title }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(topPad) + '╮' })] }), req.body.map((line, i) => {
+                const pad = Math.max(0, inner - line.length - 2);
+                return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: theme.text, children: line }), _jsx(Text, { children: ' '.repeat(pad) })] }, i));
+            }), req.diff && req.diff.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: '│' }), req.diff.map((d, i) => {
+                        const sign = d.type === 'add' ? '+' : d.type === 'remove' ? '-' : ' ';
+                        const color = d.type === 'add' ? theme.success :
+                            d.type === 'remove' ? theme.error :
+                                theme.muted;
+                        const text = `${sign} ${d.text}`.slice(0, inner - 2);
+                        const pad = Math.max(0, inner - text.length - 2);
+                        return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: color, children: text }), _jsx(Text, { children: ' '.repeat(pad) })] }, i));
+                    })] })), _jsx(Text, { color: theme.muted, children: '╰' + '─'.repeat(inner) + '╯' }), _jsxs(Text, { children: [_jsx(Text, { color: theme.success, bold: true, children: "  [y]" }), _jsx(Text, { color: theme.muted, children: " allow once   " }), _jsx(Text, { color: theme.accent, bold: true, children: "[a]" }), _jsx(Text, { color: theme.muted, children: " always (this session)   " }), _jsx(Text, { color: theme.error, bold: true, children: "[n]" }), _jsx(Text, { color: theme.muted, children: " deny" })] })] }));
+};

package/dist/ui/theme.js

@@ -1,8 +1,9 @@
 export const theme = {
-    accent: 'magentaBright', // the only non-neutral color
+    accent: 'cyan',
     text: 'white',
     muted: 'gray',
     dim: 'gray',
     error: 'red',
+    warning: 'yellow',
     success: 'green',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blyuecode",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "BLYUE Code — a coding agent by Lumen",
   "type": "module",
   "license": "MIT",