npm - @vierratale/ai - Versions diffs - 0.1.0-beta.7 → 0.1.0-beta.9 - Mend

@vierratale/ai 0.1.0-beta.7 → 0.1.0-beta.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/README.md +120 -16
package/bin/vierrataleai.js +74 -1
package/package.json +7 -1
package/src/catalog.js +78 -49
package/src/cli.js +886 -91
package/src/cmd/agent.js +1695 -0
package/src/cmd/executor.js +257 -0
package/src/cmd/tools.js +131 -0
package/src/config.js +24 -10
package/src/index.js +1 -0
package/src/installer.js +149 -6
package/src/prompts/system.json +2 -2
package/src/prompts/system.md +42 -0
package/src/providers/anthropic.js +65 -34
package/src/providers/base.js +10 -0
package/src/providers/cortex.js +236 -36
package/src/providers/gemini.js +62 -31
package/src/providers/openai.js +64 -33
package/src/session.js +195 -15
package/src/ui/branding.js +1 -1
package/src/ui/chatbox.js +271 -0
package/src/ui/terminal.js +49 -16
package/src/utils/filewriter.js +97 -0
package/src/utils/intents.js +73 -1
package/src/utils/logger.js +67 -0
package/src/utils/math.js +142 -0
package/build.sh +0 -17

package/src/prompts/system.md CHANGED Viewed

@@ -13,3 +13,45 @@ You are **VierrataleAI**, an intelligent AI assistant created by Vierratale.
 - Help users with tasks including coding, writing, analysis, and general knowledge.
 - If you don't know something, say so honestly.
 - Use markdown formatting when appropriate for readability.
+## Writing Files and Folders
+You CAN write files and folders directly to the user's disk. When the user asks
+you to create, save, or generate code, configs, scripts, projects, or any other
+files, DO NOT refuse — answer with the format below. Use this exact format for
+EACH file:
+    FILE: relative/path/to/file.js
+    ```js
+    // file content here
+    ```
+This works for any file type, including JSON and HTML. For example, write a
+config file exactly like this:
+    FILE: config.json
+    ```json
+    {
+      "name": "my-app",
+      "port": 3000
+    }
+    ```
+And a web page like this:
+    FILE: index.html
+    ```html
+    <!doctype html>
+    <html>
+    <head><title>My Page</title></head>
+    <body><h1>Hello</h1></body>
+    </html>
+    ```
+Rules:
+- Put `FILE: <path>` on its own line, immediately followed by a markdown code fence containing the file content. No text between the header and the fence.
+- Use paths relative to the user's working directory (e.g. `src/app.js`, `config.json`).
+- Emit one `FILE:` block per file; nested folders are created automatically.
+- If you need an empty folder, emit `FOLDER: <path>` on its own line.
+- When asked for a story, folk tale, legend, or myth, give the real, well-known version — use the web search results you were given when available — and also save the full story to a .txt file using `FILE: <title>.txt` followed by a ```text fence.
+- Keep any explanation short and outside of the `FILE:`/`FOLDER:` blocks.

package/src/providers/anthropic.js CHANGED Viewed

@@ -39,7 +39,7 @@ export class AnthropicProvider extends BaseProvider {
   async *stream(messages, options = {}) {
     const key = Config.get('anthropicApiKey');
-    if (!key) throw new Error('Anthropic API key not configured');
+    if (!key) throw new Error('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
     const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
@@ -51,49 +51,80 @@ export class AnthropicProvider extends BaseProvider {
       content: m.content,
     }));
-    const resp = await fetch(ANTHROPIC_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': key,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify({
-        model,
-        system: system.length ? system : undefined,
-        messages: apiMessages,
-        max_tokens: options.maxTokens || Config.get('maxTokens'),
-        stream: true,
-        temperature: options.temperature || Config.get('temperature'),
-      }),
-    });
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+    let resp;
+    try {
+      resp = await fetch(ANTHROPIC_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': key,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model,
+          system: system.length ? system : undefined,
+          messages: apiMessages,
+          max_tokens: options.maxTokens || Config.get('maxTokens'),
+          stream: true,
+          temperature: options.temperature || Config.get('temperature'),
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
+      }
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
     if (!resp.ok) {
-      throw new Error('Failed to connect to cloud engine');
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
     }
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue;
-        const data = line.slice(6);
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
         try {
-          const json = JSON.parse(data);
-          if (json.type === 'content_block_delta' && json.delta?.text) {
-            yield json.delta.text;
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
           }
-        } catch {}
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6);
+          try {
+            const json = JSON.parse(data);
+            if (json.type === 'content_block_delta' && json.delta?.text) {
+              yield json.delta.text;
+            }
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
     }
   }
 }

package/src/providers/base.js CHANGED Viewed

@@ -15,6 +15,16 @@ export class BaseProvider {
     throw new Error('stream() must be implemented');
   }
+  // Non-streaming convenience: collects the stream. Providers may override
+  // with a proper single-shot request (see CortexProvider).
+  async complete(messages, options = {}) {
+    let out = '';
+    for await (const chunk of this.stream(messages, options)) {
+      out += chunk;
+    }
+    return out;
+  }
   async listModels() {
     throw new Error('listModels() must be implemented');
   }

package/src/providers/cortex.js CHANGED Viewed

@@ -2,6 +2,25 @@ import { BaseProvider } from './base.js';
 import { Catalog } from '../catalog.js';
 import { Config } from '../config.js';
+// Keep the prompt a local engine must re-process per call bounded: the
+// system prompt plus the most recent messages. Sending the whole growing
+// history makes prompt-processing time unbounded on slow hardware.
+const MAX_CONTEXT_MESSAGES = 12;
+function buildEngineMessages(systemPrompt, messages) {
+  const engineMessages = [];
+  if (systemPrompt) {
+    engineMessages.push({ role: 'system', content: systemPrompt });
+  }
+  for (const msg of messages) {
+    engineMessages.push({ role: msg.role, content: msg.content });
+  }
+  if (engineMessages.length > MAX_CONTEXT_MESSAGES) {
+    return [engineMessages[0], ...engineMessages.slice(-(MAX_CONTEXT_MESSAGES - 1))];
+  }
+  return engineMessages;
+}
 export class CortexProvider extends BaseProvider {
   constructor() {
     super('cortex');
@@ -42,57 +61,238 @@ export class CortexProvider extends BaseProvider {
   async *stream(messages, options = {}) {
     const model = Catalog.getRealModel(options.model || Config.get('model'));
-    const systemPrompt = options.systemPrompt || '';
+    const engineMessages = buildEngineMessages(options.systemPrompt || '', messages);
-    const engineMessages = [];
-    if (systemPrompt) {
-      engineMessages.push({ role: 'system', content: systemPrompt });
-    }
-    for (const msg of messages) {
-      engineMessages.push({ role: msg.role, content: msg.content });
-    }
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 600000);
-    const resp = await fetch(`${this.host}/api/chat`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        model,
-        messages: engineMessages,
-        stream: true,
-        keep_alive: Config.get('keepAlive'),
-        options: {
-          num_ctx: Config.get('numCtx'),
-          temperature: options.temperature || Config.get('temperature'),
-        },
-      }),
-    });
+    let resp;
+    try {
+      resp = await fetch(`${this.host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: engineMessages,
+          stream: true,
+          keep_alive: Config.get('keepAlive'),
+          options: {
+            num_ctx: Config.get('numCtx'),
+            num_predict: options.maxTokens ?? Config.get('maxTokens'),
+            temperature: options.temperature || Config.get('temperature'),
+            num_thread: Config.get('numThreads'),
+          },
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the engine (no response within 600s). Make sure the local engine is running.');
+      }
+      throw new Error('[ERR-0001] Could not reach the engine (no response). Make sure the local engine is running.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
     if (!resp.ok) {
-      throw new Error('Failed to connect to backend engine');
+      throw new Error(await describeEngineError(resp, model));
     }
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 420000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the engine (no data for 420s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.message?.content) {
+              yield json.message.content;
+            }
+            if (json.done) return;
+          } catch {}
+        }
+      }
+    } finally {
+      if (idle) clearTimeout(idle);
+    }
+  }
+  // Non-streaming completion (used by the tool-planning step). Reads the
+  // streamed reply incrementally: on a slow engine a full answer can take
+  // minutes, so only a connection with no response for 180s (or an idle
+  // stream for 120s) counts as a failure - not a slowly progressing one.
+  async complete(messages, options = {}) {
+    const model = Catalog.getRealModel(options.model || Config.get('model'));
+    const engineMessages = buildEngineMessages(options.systemPrompt || '', messages);
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 600000);
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
+    if (options.signal) {
+      if (options.signal.aborted) controller.abort();
+      else options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+    }
+    let resp;
+    try {
+      resp = await fetch(`${this.host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          messages: engineMessages,
+          stream: true,
+          keep_alive: Config.get('keepAlive'),
+          options: {
+            num_ctx: Config.get('numCtx'),
+            num_predict: options.maxTokens ?? Config.get('maxTokens'),
+            temperature: options.temperature || Config.get('temperature'),
+            num_thread: Config.get('numThreads'),
+          },
+        }),
+        signal: controller.signal,
+      });
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not complete the request (no response within 600s).');
+      }
+      throw new Error('[ERR-0001] Could not reach the engine (no response). Make sure the local engine is running.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
+    if (!resp.ok) {
+      throw new Error(await describeEngineError(resp, model));
+    }
-      for (const line of lines) {
-        if (!line.trim()) continue;
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 120000);
+    };
+    settle();
+    let output = '';
+    try {
+      while (true) {
+        let value, done;
         try {
-          const json = JSON.parse(line);
-          if (json.message?.content) {
-            yield json.message.content;
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the engine (no data for 420s).');
           }
-          if (json.done) return;
-        } catch {}
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.message?.content) {
+              output += json.message.content;
+            }
+            if (json.done) {
+              buffer = '';
+              break;
+            }
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
+      controller.abort();
     }
+    return output;
+  }
+  async warmup() {
+    // Fire-and-forget: ask the engine to load the model eagerly, then abort as
+    // soon as generation starts. The engine runs with a single slot, so an
+    // in-flight non-streaming 'hi' would block the first real request.
+    const model = Catalog.getRealModel(Config.get('model'));
+    const controller = new AbortController();
+    fetch(`${this.host}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: 'hi' }],
+        stream: true,
+        keep_alive: Config.get('keepAlive'),
+        options: { num_ctx: Config.get('numCtx') },
+      }),
+      signal: controller.signal,
+    })
+      .then(async (resp) => {
+        if (!resp.ok || !resp.body) return;
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (let i = 0; i < 100; i++) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              if (JSON.parse(line).message?.content) {
+                controller.abort();
+                return;
+              }
+            } catch {}
+          }
+        }
+      })
+      .catch(() => {});
+  }
+}
+// Build a user-actionable message when the engine rejects a request (e.g. a
+// cloud model name posted to a local engine -> 404 "model not found"). The
+// engine host is deliberately kept out of the message; errors carry codes.
+async function describeEngineError(resp, model) {
+  if (/not found|does not exist|model.*missing/i.test(String(resp.statusText))) {
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
+  }
+  let body = '';
+  try {
+    body = (await resp.text()).slice(0, 300);
+  } catch {}
+  if (/not found|does not exist|model.*missing/i.test(body)) {
+    return `[ERR-0002] Model "${model}" is not installed on the engine. If you picked a cloud model, use /model VRTL-6.pro or /provider openai.`;
   }
+  return `[ERR-0003] The engine returned HTTP ${resp.status}. Check the engine status or run /model VRTL-2.fast.`;
 }

package/src/providers/gemini.js CHANGED Viewed

@@ -39,7 +39,7 @@ export class GeminiProvider extends BaseProvider {
   async *stream(messages, options = {}) {
     const key = Config.get('geminiApiKey');
-    if (!key) throw new Error('Gemini API key not configured');
+    if (!key) throw new Error('[ERR-0004] Cloud API key not configured. Add it to the config and try again.');
     const model = this._resolveModel(options);
     const systemPrompt = options.systemPrompt || '';
@@ -52,46 +52,77 @@ export class GeminiProvider extends BaseProvider {
       contents.unshift({ role: 'user', parts: [{ text: `System: ${systemPrompt}` }] });
     }
-    const resp = await fetch(
-      `${GEMINI_URL}/${model}:streamGenerateContent?key=${key}&alt=sse`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          contents,
-          generationConfig: {
-            temperature: options.temperature || Config.get('temperature'),
-            maxOutputTokens: options.maxTokens || Config.get('maxTokens'),
-          },
-        }),
+    const controller = new AbortController();
+    const connectTimer = setTimeout(() => controller.abort(), 240000);
+    let resp;
+    try {
+      resp = await fetch(
+        `${GEMINI_URL}/${model}:streamGenerateContent?key=${key}&alt=sse`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            contents,
+            generationConfig: {
+              temperature: options.temperature || Config.get('temperature'),
+              maxOutputTokens: options.maxTokens || Config.get('maxTokens'),
+            },
+          }),
+          signal: controller.signal,
+        }
+      );
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        throw new Error('[ERR-0001] Could not reach the API (no response within 60s). Check your network connection.');
       }
-    );
+      throw new Error('[ERR-0001] Could not reach the API (no response). Check your network connection.');
+    } finally {
+      clearTimeout(connectTimer);
+    }
     if (!resp.ok) {
-      throw new Error('Failed to connect to cloud engine');
+      throw new Error('[ERR-0003] The cloud provider returned HTTP ' + resp.status + '. Check your API key in config.');
     }
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue;
-        const data = line.slice(6);
+    let idle = null;
+    const settle = () => {
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(() => controller.abort(), 240000);
+    };
+    settle();
+    try {
+      while (true) {
+        let value, done;
         try {
-          const json = JSON.parse(data);
-          const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
-          if (text) yield text;
-        } catch {}
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (err.name === 'AbortError') {
+            throw new Error('[ERR-0001] Lost the connection to the cloud API (no data for 60s).');
+          }
+          throw err;
+        }
+        if (done) break;
+        settle();
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6);
+          try {
+            const json = JSON.parse(data);
+            const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (text) yield text;
+          } catch {}
+        }
       }
+    } finally {
+      if (idle) clearTimeout(idle);
     }
   }
 }