@vierratale/ai 0.1.0-beta.8 → 0.1.0-fixfetch-beta9.5

package/src/utils/filewriter.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync, statSync, writeFileSync } from 'fs';
+import { dirname, resolve, sep } from 'path';
+
+const FILE_RE = /^FILE:\s*(.+?)\s*$/i;
+const FOLDER_RE = /^FOLDER:\s*(.+?)\s*$/i;
+
+export class FileWriter {
+  static parse(text) {
+    const files = [];
+    const folders = [];
+    const lines = String(text || '').split('\n');
+    let i = 0;
+    while (i < lines.length) {
+      let m = FILE_RE.exec(lines[i]);
+      if (m) {
+        const path = m[1].trim();
+        let j = i + 1;
+        while (j < lines.length && lines[j].trim() === '') j++;
+        if (j < lines.length && lines[j].startsWith('```')) {
+          const start = j + 1;
+          let end = start;
+          while (end < lines.length && !lines[end].startsWith('```')) end++;
+          if (end < lines.length) {
+            files.push({
+              path,
+              language: lines[j].slice(3).trim(),
+              content: lines.slice(start, end).join('\n'),
+            });
+            i = end + 1;
+            continue;
+          }
+        }
+      }
+      m = FOLDER_RE.exec(lines[i]);
+      if (m) {
+        folders.push(m[1].trim());
+      }
+      i++;
+    }
+    return { files, folders };
+  }
+
+  static resolveTarget(path) {
+    const base = resolve(process.cwd());
+    const target = resolve(base, path);
+    if (target !== base && !target.startsWith(base + sep)) {
+      throw new Error(`Refusing to write outside the working directory: ${path}`);
+    }
+    return target;
+  }
+
+  static async write({ files = [], folders = [], overwrite = false, confirm } = {}) {
+    const results = [];
+
+    for (const p of folders) {
+      try {
+        mkdirSync(this.resolveTarget(p), { recursive: true });
+        results.push({ kind: 'folder', path: p, target: this.resolveTarget(p), status: 'created' });
+      } catch (err) {
+        results.push({ kind: 'folder', path: p, status: 'error', error: err.message });
+      }
+    }
+
+    for (const f of files) {
+      let target;
+      try {
+        target = this.resolveTarget(f.path);
+      } catch (err) {
+        results.push({ kind: 'file', path: f.path, status: 'error', error: err.message });
+        continue;
+      }
+      if (existsSync(target) && statSync(target).isDirectory()) {
+        results.push({ kind: 'file', path: f.path, target, status: 'error', error: 'Target is a directory' });
+        continue;
+      }
+      if (existsSync(target) && confirm) {
+        const ok = await confirm(`Overwrite ${f.path}?`);
+        if (!ok) {
+          results.push({ kind: 'file', path: f.path, target, status: 'skipped', error: 'Declined' });
+          continue;
+        }
+      } else if (existsSync(target) && !overwrite) {
+        results.push({ kind: 'file', path: f.path, target, status: 'skipped', error: 'File already exists' });
+        continue;
+      }
+      try {
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, f.content, 'utf-8');
+        results.push({ kind: 'file', path: f.path, target, status: 'written' });
+      } catch (err) {
+        results.push({ kind: 'file', path: f.path, target, status: 'error', error: err.message });
+      }
+    }
+
+    return results;
+  }
+}

package/src/utils/intents.js

@@ -19,14 +19,74 @@ const SELF_PHRASES = [
   'what engine', 'which engine', 'are you gpt', 'are you chatgpt',
 ];
 
+const ACTION_VERBS = 'create|make|write|save|generate|build|add|new|update|edit|install|put|set';
+const FILE_THINGS = 'file|folder|directory|project|code|script|config|\\.json|app|readme|package\\.json|website|html|css';
+const INFO_ASK = /^(how|what|why|when|where|which)\b/i;
+const FILE_REQUEST = new RegExp(`\\b(${ACTION_VERBS})\\b[^.!?]{0,80}\\b(${FILE_THINGS})\\b`, 'i');
+
+const STORY_WORDS = [
+  'story', 'stories', 'tale', 'tales', 'legend', 'legends',
+  'myth', 'myths', 'fable', 'fables', 'folklore', 'folktale',
+  'folk tale', 'fairytale', 'fairy tale',
+].join('|');
+const STORY_LINKS = 'about|of|regarding|recounting|called|named';
+const TRIM_TAIL = '\\s+(?:and|in|into)\\b|\\s*[.!?]|$';
+
+const STORY_SUBJECT_PATTERN = new RegExp(
+  `\\b(?:${STORY_WORDS})\\s+(?:${STORY_LINKS})\\s+[a-z0-9]{3,}`, 'i',
+);
+const STORY_ASK_PATTERN = new RegExp(
+  `\\b(?:tell|write|narrate|recite|make|create|generate|give|share|hear|listen to)\\b[^.!?\\n]{0,60}\\b(?:${STORY_WORDS})\\b`, 'i',
+);
+const STORY_CAPTURE = new RegExp(
+  `\\b(?:${STORY_WORDS})\\s+(?:${STORY_LINKS})\\s+([^.!?\\n]{2,}?)\\s*(?=${TRIM_TAIL})`, 'i',
+);
+const ABOUT_CAPTURE = /\b(?:tell me|talk|read|learn|research|hear|know|find out|look up|speak|write|give)\b[^.!?\n]{0,30}\babout\s+([^.!?\n]{2,}?)\s*(?=\s+(?:and|in|into)\b|\s*[.!?]|$)/i;
+const PLACE_PATTERN = /\bfrom\s+[a-z][a-z\s'.-]{1,40}$/i;
+
+const GREETINGS = new Set([
+  'hi', 'hello', 'hey', 'hii', 'heyy', 'howdy', 'yo', 'hai',
+  'halo', 'hallo', 'hola', 'hiya', 'sup', 'good morning',
+  'good afternoon', 'good evening', 'good night', 'selamat pagi',
+  'selamat siang', 'selamat sore', 'selamat malam', 'assalamualaikum',
+]);
+
+export function looksLikeStoryRequest(text) {
+  return STORY_ASK_PATTERN.test(text) || STORY_SUBJECT_PATTERN.test(text);
+}
+
+export function extractSearchTopic(text) {
+  const s = String(text).trim();
+  const story = STORY_CAPTURE.exec(s);
+  if (story) return story[1].trim();
+  const about = ABOUT_CAPTURE.exec(s);
+  return about ? about[1].trim() : null;
+}
+
 export function detectIntent(text) {
   const lower = text.toLowerCase().trim();
   if (lower.startsWith('/')) return { type: 'command' };
 
+  if (GREETINGS.has(lower)) {
+    return { type: 'greeting' };
+  }
+
   if (SELF_PHRASES.some((p) => lower.includes(p))) {
     return { type: 'self' };
   }
 
+  if (STORY_SUBJECT_PATTERN.test(lower) || PLACE_PATTERN.test(lower)) {
+    return { type: 'knowledge' };
+  }
+
+  const isKnowledgePrefixed = KNOWLEDGE_PREFIXES.some(
+    (p) => lower.startsWith(p + ' ') || lower === p,
+  );
+
+  if (!INFO_ASK.test(lower) && !isKnowledgePrefixed && FILE_REQUEST.test(lower)) {
+    return { type: 'chat' };
+  }
+
   const isQuestion = /\?$/.test(lower);
   const firstWord = lower.split(/\s+/)[0] || '';
 
@@ -34,7 +94,7 @@ export function detectIntent(text) {
   if (isQuestion && QUESTION_PREFIXES.includes(firstWord)) {
     needsWeb = true;
   }
-  if (KNOWLEDGE_PREFIXES.some((p) => lower.startsWith(p + ' ') || lower === p)) {
+  if (isKnowledgePrefixed) {
     needsWeb = true;
   }
 

package/src/utils/logger.js

@@ -0,0 +1,67 @@
+import { readFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { Config } from '../config.js';
+
+const MAX_LINE = 2000;
+
+function pad(n) {
+  return String(n).padStart(2, '0');
+}
+
+function dateStamp(d) {
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}`;
+}
+
+function timeStamp(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+function cap(text) {
+  const s = String(text ?? '');
+  return s.length > MAX_LINE ? `${s.slice(0, MAX_LINE)}…` : s;
+}
+
+// Automatic activity logger. Writes one timestamped file per day into the
+// config directory (logs/). A no-op until init() is called, so tests and
+// library consumers never accidentally write into the real logs folder.
+class Logger {
+  constructor() {
+    this.dir = null;
+    this.file = null;
+    this._initialized = false;
+  }
+
+  init(opts = {}) {
+    if (this._initialized) return this;
+    this.dir = opts.baseDir ? join(opts.baseDir, 'logs') : join(Config.getConfigDir(), 'logs');
+    mkdirSync(this.dir, { recursive: true });
+    this.file = join(this.dir, `vierrataleai-${dateStamp(new Date())}.log`);
+    this._initialized = true;
+    return this;
+  }
+
+  log(event, message = '') {
+    if (!this._initialized) return '';
+    const line = `${timeStamp(new Date())} [${event}] ${cap(message)}`;
+    try {
+      appendFileSync(this.file, line + '\n');
+    } catch {}
+    return line;
+  }
+
+  getPath() {
+    return this.file;
+  }
+
+  tail(count = 30) {
+    if (!this._initialized || !existsSync(this.file)) return [];
+    try {
+      return readFileSync(this.file, 'utf-8').split('\n').filter(Boolean).slice(-count);
+    } catch {
+      return [];
+    }
+  }
+}
+
+export { Logger };
+export const logger = new Logger();

package/src/utils/math.js

@@ -0,0 +1,142 @@
+// utils/math.js - Deterministic, safe math evaluator.
+// Parses arithmetic ( + - * / ^ % parentheses, decimals, scientific notation )
+// WITHOUT using eval(), so it can never execute arbitrary code. Returns null
+// when the input is not a clean math expression, so callers fall back to the
+// model.
+
+// Extract a bare arithmetic expression from a line of chat text.
+export function extractMathExpression(text) {
+  const s = String(text || '').trim();
+  // Strip a leading question/math verb phrase if present.
+  const cleaned = s.replace(
+    /^(?:what(?:'s| is| are)|what's|compute|calculate|solve|evaluate|equals?)\b\s*/i,
+    ''
+  ).replace(/\??$/, '').trim();
+  const expr = cleaned.replace(/[?,!.]$/, '').trim();
+  if (!expr) return null;
+  // Guard: must be purely numeric + arithmetic operators + parens + spaces.
+  if (!/^[0-9+\-*\/^%().\s]+$/.test(expr)) return null;
+  if (!/\d/.test(expr)) return null;
+  if (/[a-zA-Z]/.test(expr)) return null;
+  // Must contain at least one operator (otherwise "2" alone isn't a math ask).
+  if (!/[\+\-\*\/\^%]/.test(expr)) return null;
+  return expr;
+}
+
+// Tokenize an expression into numbers and operators.
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  const n = expr.length;
+  while (i < n) {
+    const c = expr[i];
+    if (/\s/.test(c)) { i++; continue; }
+    if ('+-*/^%()'.includes(c)) {
+      tokens.push(c);
+      i++;
+      continue;
+    }
+    // read a number (int, decimal, scientific)
+    const num = expr.slice(i).match(/^(\d+(?:\.\d+)?|\.\d+)([eE][+-]?\d+)?/);
+    if (!num) return null;
+    tokens.push(parseFloat(num[0]));
+    i += num[0].length;
+  }
+  return tokens;
+}
+
+// Recursive-descent parser with correct precedence:
+//   expr   := term (('+'|'-') term)*
+//   term   := power (('*'|'/'|'%') power)*
+//   power  := unary ('^' power)?        right-associative
+//   unary  := ('+'|'-') unary | factor
+//   factor := '(' expr ')' | number
+class Parser {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+  peek() { return this.tokens[this.pos]; }
+  next() { return this.tokens[this.pos++]; }
+  expect(val) {
+    const t = this.next();
+    if (t !== val) throw new Error('syntax error');
+  }
+  parseExpr() { return this.parseTerm(); }
+  parseTerm() {
+    let left = this.parseMul();
+    while (['+', '-'].includes(this.peek())) {
+      const op = this.next();
+      const right = this.parseMul();
+      left = op === '+' ? left + right : left - right;
+    }
+    return left;
+  }
+  parseMul() {
+    let left = this.parsePower();
+    while (['*', '/', '%'].includes(this.peek())) {
+      const op = this.next();
+      const right = this.parsePower();
+      if (op === '*') left = left * right;
+      else if (op === '/') left = left / right;
+      else left = left % right;
+    }
+    return left;
+  }
+  parsePower() {
+    let left = this.parseUnary();
+    if (this.peek() === '^') {
+      this.next();
+      const right = this.parsePower();
+      left = Math.pow(left, right);
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.peek() === '+') { this.next(); return this.parseUnary(); }
+    if (this.peek() === '-') {
+      this.next();
+      return -this.parseUnary();
+    }
+    return this.parseFactor();
+  }
+  parseFactor() {
+    const t = this.peek();
+    if (t === '(') {
+      this.next();
+      const v = this.parseExpr();
+      this.expect(')');
+      return v;
+    }
+    if (typeof t === 'number') {
+      this.next();
+      return t;
+    }
+    throw new Error('syntax error');
+  }
+}
+
+export function evaluateMath(expr) {
+  try {
+    const tokens = tokenize(expr);
+    if (!tokens || !tokens.length) return null;
+    const p = new Parser(tokens);
+    const result = p.parseExpr();
+    if (p.pos !== tokens.length) return null; // leftover tokens = not a clean expr
+    if (!Number.isFinite(result)) return null;
+    // Round to avoid floating point noise like 0.30000000000000004
+    const rounded = Math.round((result + Number.EPSILON) * 1e10) / 1e10;
+    return Number(rounded.toPrecision(12));
+  } catch {
+    return null;
+  }
+}
+
+// Front-door: given a chat line, return a clean math answer or null.
+export function trySolveMath(text) {
+  const expr = extractMathExpression(text);
+  if (!expr) return null;
+  const value = evaluateMath(expr);
+  if (value === null) return null;
+  return `${expr} = ${value}`;
+}

package/src/utils/webfetch.js

@@ -1,4 +1,6 @@
-const UA = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36';
+const UA =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ' +
+  '(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36';
 
 const MAX_BYTES = 200000; // 200KB cap
 const MAX_TEXT = 8000;    // ~8k chars of readable text
@@ -8,6 +10,40 @@ const BLOCK_TAGS = new Set([
   'nav', 'footer', 'aside', 'iframe', 'form', 'button', 'noscript',
 ]);
 
+// Body markers that indicate an anti-bot wall instead of real content.
+const BLOCK_MARKERS = [
+  'just a moment',
+  'client challenge',
+  'checking your browser',
+  'enable javascript and cookies',
+  'cf-chl',
+  'challenge-platform',
+  'attention required!',
+  'powershell install',
+];
+
+// Browser-like headers so header-based bot checks see a real browser.
+function browserHeaders(accept = 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8') {
+  return {
+    'User-Agent': UA,
+    Accept: accept,
+    'Accept-Language': 'en-US,en;q=0.9',
+    Connection: 'keep-alive',
+    'Upgrade-Insecure-Requests': '1',
+    'Sec-Fetch-Dest': accept.startsWith('application/json') ? 'empty' : 'document',
+    'Sec-Fetch-Mode': accept.startsWith('application/json') ? 'cors' : 'navigate',
+    'Sec-Fetch-Site': 'none',
+    'Sec-Fetch-User': accept.startsWith('application/json') ? '?0' : '?1',
+    'Cache-Control': 'no-cache',
+    Pragma: 'no-cache',
+  };
+}
+
+export function isBlockedBody(html) {
+  const s = String(html || '').toLowerCase().slice(0, 4000);
+  return BLOCK_MARKERS.some((m) => s.includes(m));
+}
+
 export class WebFetch {
   static normalizeUrl(input) {
     const trimmed = (input || '').trim();
@@ -34,10 +70,45 @@ export class WebFetch {
       throw new Error('Invalid URL. Provide a valid http(s) address.');
     }
 
+    let finalUrl = url;
+    let html = '';
+    let blocked = false;
+    try {
+      const res = await this._fetchHtml(url);
+      finalUrl = res.url;
+      html = res.html;
+      const status = res.status;
+      blocked = status !== 200 || isBlockedBody(html);
+    } catch (err) {
+      blocked = true;
+      // _fetchHtml errors are network/cert/PROTOCOL issues; a fallback may
+      // still succeed (e.g. registry API is reachable even when the HTML
+      // page's CDN is not).
+    }
+
+    // Bot-walled npm/pypi pages degrade to their open JSON API.
+    if (blocked) {
+      const registry = await this._registryFallback(finalUrl || url, maxText);
+      if (registry) return registry;
+    }
+
+    if (blocked) {
+      const status = 'blocked';
+      throw new Error(`Request blocked (${status}) for ${finalUrl || url}`);
+    }
+
+    return {
+      url: finalUrl,
+      title: this._extractTitle(html),
+      text: this._extractText(html).slice(0, maxText),
+    };
+  }
+
+  static async _fetchHtml(url) {
     let resp;
     try {
       resp = await fetch(url, {
-        headers: { 'User-Agent': UA, Accept: 'text/html,application/xhtml+xml' },
+        headers: browserHeaders(),
         redirect: 'follow',
         signal: AbortSignal.timeout(15000),
       });
@@ -45,11 +116,6 @@ export class WebFetch {
       throw new Error(`Could not reach ${url}`);
     }
 
-    if (!resp.ok) {
-      throw new Error(`Request failed (${resp.status}) for ${url}`);
-    }
-
-    // Refuse to read the whole body past the cap.
     const reader = resp.body.getReader();
     const decoder = new TextDecoder('utf-8', { fatal: false });
     let html = '';
@@ -63,13 +129,95 @@ export class WebFetch {
     reader.cancel();
     html += decoder.decode();
 
+    return { url: resp.url || url, html, status: resp.status };
+  }
+
+  // --- Registry fallback (npm + PyPI) via their open JSON APIs ---------- //
+
+  static async _registryFallback(url, maxText) {
+    const npm = this._npmSpec(url);
+    if (npm) {
+      try {
+        return await this._npmFallback(npm, url, maxText);
+      } catch {}
+    }
+    const pypi = this._pypiSpec(url);
+    if (pypi) {
+      try {
+        return await this._pypiFallback(pypi, url, maxText);
+      } catch {}
+    }
+    return null;
+  }
+
+  static _npmSpec(url) {
+    const m = /npmjs\.\w+\/package\/([@a-zA-Z0-9._~-]+(?:\/[@a-zA-Z0-9._~-]+)?)/i.exec(url);
+    return m ? m[1] : null;
+  }
+
+  static _pypiSpec(url) {
+    const m = /pypi\.org\/project\/([a-zA-Z0-9._-]+)/i.exec(url);
+    return m ? m[1] : null;
+  }
+
+  static async _fetchJson(apiUrl) {
+    const resp = await fetch(apiUrl, {
+      headers: browserHeaders('application/json'),
+      redirect: 'follow',
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) throw new Error(`API ${resp.status}`);
+    return resp.json();
+  }
+
+  static async _npmFallback(spec, pageUrl, maxText) {
+    const pkg = encodeURIComponent(spec); // '@vierratale/ai' -> %40vierratale%2Fai
+    const data = await this._fetchJson(`https://registry.npmjs.org/${pkg}`);
+    const version =
+      (data['dist-tags'] && (data['dist-tags'].latest || data['dist-tags'].beta)) ||
+      Object.keys(data.versions || {})[0];
+    const meta = (data.versions && data.versions[version]) || {};
+    const deps = meta.dependencies || data.dependencies || {};
+    const lines = [
+      `${data.name} (npm package)`,
+      `Latest version: ${version}`,
+      meta.description || data.description || '',
+      `License: ${meta.license || data.license || 'N/A'}`,
+      `Dependencies: ${Object.keys(deps).length}`,
+      '',
+    ];
+    const readme = String(data.readme || '').trim();
+    if (readme) lines.push(readme.slice(0, maxText));
     return {
-      url: resp.url || url,
-      title: this._extractTitle(html),
-      text: this._extractText(html).slice(0, maxText),
+      url: pageUrl,
+      title: `${data.name} · npm`,
+      text: lines.filter(Boolean).join('\n').slice(0, maxText),
+    };
+  }
+
+  static async _pypiFallback(spec, pageUrl, maxText) {
+    const data = await this._fetchJson(`https://pypi.org/pypi/${encodeURIComponent(spec)}/json`);
+    const info = data.info || {};
+    const lines = [
+      `${info.name} (PyPI package)`,
+      `Version: ${info.version}`,
+      info.summary || '',
+      `Requires Python: ${info.requires_python || 'N/A'}`,
+      `License: ${info.license || 'N/A'}`,
+      `Home: ${info.home_page || info.project_url || 'N/A'}`,
+      '',
+    ];
+    const desc = String(info.description || '').trim();
+    if (desc) lines.push(desc.slice(0, maxText));
+    return {
+      url: pageUrl,
+      title: `${info.name} · PyPI`,
+      text: lines.filter(Boolean).join('\n').slice(0, maxText),
     };
   }
 
+  // --- extraction -------------------------------------------------------- //
+
   static _extractTitle(html) {
     const m = /<title[^>]*>([^<]*)<\/title>/i.exec(html);
     return m ? this._stripEntities(m[1].trim()) : '';
@@ -112,4 +260,4 @@ export class WebFetch {
       .replace(/\s+/g, ' ')
       .trim();
   }
-}
+}

package/build.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-# Build VierrataleAI Node.js version for packaging
-set -e
-
-cd "$(dirname "$0")"
-
-echo "Installing dependencies..."
-npm install
-
-echo "Testing..."
-node bin/vierrataleai.js --version
-
-echo "Packaging..."
-npm pack
-
-echo "Build complete!"
-echo "To publish: npm publish --tag beta"