nothumanallowed 14.1.21 → 14.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "14.1.21",
+  "version": "14.1.22",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '14.1.21';
+export const VERSION = '14.1.22';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/webcraft.mjs

@@ -544,6 +544,52 @@ function countTokens(text) {
   return Math.ceil((text || '').length / 4);
 }
 
+/**
+ * Simulated streaming: for providers that return full text at once (NHA/Liara),
+ * we split the text into ~20-char chunks and emit them with setImmediate gaps
+ * so the browser receives a real byte-by-byte stream over SSE.
+ */
+async function emitTextAsStream(text, onChunk) {
+  const CHUNK_SIZE = 20;
+  for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+    onChunk(text.slice(i, i + CHUNK_SIZE));
+    await new Promise((r) => setImmediate(r));
+  }
+}
+
+/**
+ * Detects if an LLM output appears to be truncated / incomplete.
+ * Returns true if the file likely needs a continuation call.
+ */
+function isFileTruncated(content, filename) {
+  if (!content || content.length < 10) return true;
+  const trimmed = content.trimEnd();
+  const ext = filename.split('.').pop()?.toLowerCase();
+
+  // Common truncation signs: ends mid-statement without closing bracket/brace
+  if (ext === 'js' || ext === 'mjs' || ext === 'ts') {
+    // Balanced braces check (fast approximation)
+    const open = (trimmed.match(/\{/g) || []).length;
+    const close = (trimmed.match(/\}/g) || []).length;
+    if (open > close + 2) return true;
+    // Last meaningful line should not end with an operator or comma
+    const lastLine = trimmed.split('\n').pop()?.trim() ?? '';
+    if (/[,({=+\-*/<>|&]$/.test(lastLine)) return true;
+  }
+  if (ext === 'css') {
+    const open = (trimmed.match(/\{/g) || []).length;
+    const close = (trimmed.match(/\}/g) || []).length;
+    if (open > close + 1) return true;
+  }
+  if (ext === 'html') {
+    if (!trimmed.includes('</html>') && !trimmed.includes('</body>')) return true;
+  }
+  if (ext === 'json') {
+    try { JSON.parse(trimmed); } catch { return true; }
+  }
+  return false;
+}
+
 async function runGenerate(config, projectName, description, blocks, authFields, emit) {
   const blocksDesc = Object.entries(blocks)
     .filter(([, enabled]) => enabled)
@@ -666,20 +712,43 @@ ${prevContext ? `Recent files generated (for consistency):\n${prevContext}\n\n`
     const fileTokensIn = countTokens(fileSys) + countTokens(filePrompt);
 
     try {
+      // Collect full LLM output first, then stream it to the client in small chunks.
+      // This gives real word-by-word animation even with non-streaming providers (NHA/Liara).
+      let rawOutput = '';
       await callLLMStream(config, fileSys, filePrompt, (chunk) => {
-        fileContent += chunk;
-        emit({ type: 'file_chunk', name: fileSpec.name, chunk, fi: fi + 1, total: filePlan.length });
+        rawOutput += chunk;
       }, { max_tokens: maxTokens });
 
+      // Strip markdown fences if LLM wrapped the output
+      rawOutput = rawOutput
+        .replace(/^```[\w]*\n/, '').replace(/\n```$/, '')
+        .replace(/^```[\w]*\r\n/, '').replace(/\r\n```$/, '').trim();
+
+      // Continuation: if the file appears truncated, ask the model to continue
+      if (isFileTruncated(rawOutput, fileSpec.name)) {
+        const contPrompt = `Continue writing the file ${fileSpec.name} exactly from where it was cut off. Output ONLY the continuation (no repetition of what was already written, no explanation):
+
+${rawOutput.slice(-800)}`;
+        let continuation = '';
+        await callLLMStream(config, fileSys, contPrompt, (chunk) => {
+          continuation += chunk;
+        }, { max_tokens: Math.min(maxTokens, 4096) });
+        continuation = continuation
+          .replace(/^```[\w]*\n/, '').replace(/\n```$/, '').trim();
+        rawOutput = rawOutput + '\n' + continuation;
+      }
+
+      fileContent = rawOutput;
+
+      // Stream the final content to the browser in small chunks for animation
+      await emitTextAsStream(fileContent, (chunk) => {
+        emit({ type: 'file_chunk', name: fileSpec.name, chunk, fi: fi + 1, total: filePlan.length });
+      });
+
       const fileTokensOut = countTokens(fileContent);
       totalTokensIn += fileTokensIn;
       totalTokensOut += fileTokensOut;
 
-      // Strip markdown fences if LLM wrapped the output anyway
-      fileContent = fileContent
-        .replace(/^```[\w]*\n/, '').replace(/\n```$/, '')
-        .replace(/^```[\w]*\r\n/, '').replace(/\r\n```$/, '').trim();
-
       // Quick syntax check for JS/TS files
       if (fileSpec.name.endsWith('.js') || fileSpec.name.endsWith('.mjs')) {
         try { new Function(fileContent); } catch (e) { syntaxError = e.message.replace(/\n.*/s, ''); }