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

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/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"