nothumanallowed 13.5.56 → 13.5.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.56",
+  "version": "13.5.58",
   "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/commands/ui.mjs

@@ -3937,6 +3937,13 @@ ${completedHeadings ? `## SECTIONS ALREADY WRITTEN (headings only):\n${completed
           '(aggiungi qui note per sessioni future — es. "usa Tailwind invece di BEM", "API key in .env.local")',
         ].join('\n');
         fs.writeFileSync(path.join(projDir, 'webcraft-agent.md'), agentMd, 'utf8');
+        // Create default context files (skills, memory, provider) if not present
+        const ctxDir = path.join(projDir, 'skills');
+        if (!fs.existsSync(ctxDir)) fs.mkdirSync(ctxDir, { recursive: true });
+        for (const def of ['memory.md', 'liara.md', 'skills.md']) {
+          const fp = path.join(ctxDir, def);
+          if (!fs.existsSync(fp)) fs.writeFileSync(fp, '', 'utf8');
+        }
         sendJSON(res, 200, { ok: true, dir: projDir });
         logRequest(method, pathname, 200, Date.now() - start);
         return;
@@ -3966,41 +3973,76 @@ ${completedHeadings ? `## SECTIONS ALREADY WRITTEN (headings only):\n${completed
         return;
       }
 
-      // GET /api/studio/webcraft/skills/:name → { skills: [{name, content}] }
+      // GET /api/studio/webcraft/skills/:name → { skills: [{name, content, type}] }
       if (pathname.startsWith('/api/studio/webcraft/skills/') && method === 'GET') {
         const projName = decodeURIComponent(pathname.replace('/api/studio/webcraft/skills/', '')).replace(/[^a-zA-Z0-9_-]/g, '');
         const skillsDir = path.join(os.homedir(), '.nha', 'webcraft', projName, 'skills');
+        // Ensure the 3 default files always exist on disk
+        const WC_DEFAULTS = [
+          { name: 'memory.md', type: 'memory' },
+          { name: 'liara.md',  type: 'provider' },
+          { name: 'skills.md', type: 'skill' },
+        ];
+        if (!fs.existsSync(skillsDir)) fs.mkdirSync(skillsDir, { recursive: true });
+        for (const def of WC_DEFAULTS) {
+          const fp = path.join(skillsDir, def.name);
+          if (!fs.existsSync(fp)) fs.writeFileSync(fp, '', 'utf8');
+        }
+        // Load type index
+        const indexPath = path.join(skillsDir, '_index.json');
+        let typeIndex = {};
+        if (fs.existsSync(indexPath)) {
+          try { typeIndex = JSON.parse(fs.readFileSync(indexPath, 'utf8')); } catch(_) {}
+        }
+        // Default types for well-known filenames
+        const defaultType = (n) => n === 'memory.md' ? 'memory' : n === 'liara.md' ? 'provider' : 'skill';
         const skills = [];
-        if (fs.existsSync(skillsDir)) {
-          for (const fname of fs.readdirSync(skillsDir)) {
-            if (!fname.endsWith('.md')) continue;
-            try {
-              const content = fs.readFileSync(path.join(skillsDir, fname), 'utf8');
-              skills.push({ name: fname.replace(/\.md$/, ''), content });
-            } catch(_) {}
-          }
+        for (const fname of fs.readdirSync(skillsDir)) {
+          if (!fname.endsWith('.md')) continue;
+          try {
+            const content = fs.readFileSync(path.join(skillsDir, fname), 'utf8');
+            const type = typeIndex[fname] || defaultType(fname);
+            skills.push({ name: fname, content, type });
+          } catch(_) {}
         }
         sendJSON(res, 200, { skills });
         logRequest(method, pathname, 200, Date.now() - start);
         return;
       }
 
-      // POST /api/studio/webcraft/skills/:name  { skills: [{name, content}] }
+      // POST /api/studio/webcraft/skills/:name  { skills: [{name, content, type}] }
       if (pathname.startsWith('/api/studio/webcraft/skills/') && method === 'POST') {
         const projName = decodeURIComponent(pathname.replace('/api/studio/webcraft/skills/', '')).replace(/[^a-zA-Z0-9_-]/g, '');
         const body = await parseBody(req);
         const skills = body.skills || [];
         const skillsDir = path.join(os.homedir(), '.nha', 'webcraft', projName, 'skills');
         if (!fs.existsSync(skillsDir)) fs.mkdirSync(skillsDir, { recursive: true });
-        // Remove all existing .md files, then write current set
+        // Build set of incoming names (normalised)
+        const incoming = new Set(skills.map(s => {
+          let n = (s.name || '').replace(/[^a-zA-Z0-9_.-]/g, '_');
+          if (!n.endsWith('.md')) n += '.md';
+          return n;
+        }));
+        // Remove .md files not in incoming set (but never remove the 3 defaults — only clear them)
+        const WC_KEEP = new Set(['memory.md', 'liara.md', 'skills.md']);
         for (const fname of fs.readdirSync(skillsDir)) {
-          if (fname.endsWith('.md')) fs.unlinkSync(path.join(skillsDir, fname));
+          if (!fname.endsWith('.md')) continue;
+          if (!incoming.has(fname) && !WC_KEEP.has(fname)) fs.unlinkSync(path.join(skillsDir, fname));
         }
+        // Write/update all skills; always keep defaults even if not in incoming (write empty)
+        const typeIndex = {};
         for (const skill of skills) {
           if (!skill.name) continue;
-          const safeName = skill.name.replace(/[^a-zA-Z0-9_-]/g, '_');
-          fs.writeFileSync(path.join(skillsDir, safeName + '.md'), skill.content || '', 'utf8');
+          let safeName = skill.name.replace(/[^a-zA-Z0-9_.-]/g, '_');
+          if (!safeName.endsWith('.md')) safeName += '.md';
+          fs.writeFileSync(path.join(skillsDir, safeName), skill.content || '', 'utf8');
+          typeIndex[safeName] = skill.type || 'skill';
         }
+        // Ensure defaults exist
+        for (const def of ['memory.md', 'liara.md', 'skills.md']) {
+          if (!fs.existsSync(path.join(skillsDir, def))) fs.writeFileSync(path.join(skillsDir, def), '', 'utf8');
+        }
+        fs.writeFileSync(path.join(skillsDir, '_index.json'), JSON.stringify(typeIndex), 'utf8');
         sendJSON(res, 200, { ok: true });
         logRequest(method, pathname, 200, Date.now() - start);
         return;
@@ -4449,18 +4491,30 @@ module.exports = { get, set, del, exists };
           const agentMemoryPath = path.join(sandboxDir, 'webcraft-agent.md');
           const agentMemory = fs.existsSync(agentMemoryPath) ? fs.readFileSync(agentMemoryPath, 'utf8') : '';
 
-          // Load skills files from skills/ subfolder
+          // Load context files from skills/ subfolder (skills, memory, provider)
           const skillsDir = path.join(sandboxDir, 'skills');
           let skillsContext = '';
           if (fs.existsSync(skillsDir)) {
-            const skillFiles = fs.readdirSync(skillsDir).filter(f => f.endsWith('.md'));
-            if (skillFiles.length > 0) {
-              skillsContext = '\nSKILLS DEL PROGETTO:\n' + skillFiles.map(fname => {
-                const skillName = fname.replace(/\.md$/, '');
+            const indexPath = path.join(skillsDir, '_index.json');
+            let typeIndex = {};
+            if (fs.existsSync(indexPath)) { try { typeIndex = JSON.parse(fs.readFileSync(indexPath, 'utf8')); } catch(_) {} }
+            const defaultType = (n) => n === 'memory.md' ? 'memory' : n === 'liara.md' ? 'provider' : 'skill';
+            const sections = { memory: [], provider: [], skill: [] };
+            for (const fname of fs.readdirSync(skillsDir)) {
+              if (!fname.endsWith('.md')) continue;
+              try {
                 const content = fs.readFileSync(path.join(skillsDir, fname), 'utf8');
-                return `--- SKILL: ${skillName} ---\n${content}`;
-              }).join('\n\n') + '\n';
+                if (!content.trim()) continue; // skip empty files
+                const type = typeIndex[fname] || defaultType(fname);
+                sections[type] = sections[type] || [];
+                sections[type].push(`### ${fname}\n${content}`);
+              } catch(_) {}
             }
+            const parts = [];
+            if (sections.memory.length) parts.push('MEMORIA PROGETTO:\n' + sections.memory.join('\n\n'));
+            if (sections.provider.length) parts.push('ISTRUZIONI MODELLO AI:\n' + sections.provider.join('\n\n'));
+            if (sections.skill.length) parts.push('SKILLS & PATTERN:\n' + sections.skill.join('\n\n'));
+            if (parts.length) skillsContext = '\n' + parts.join('\n\n') + '\n';
           }
 
           // Read all project files to give agent full context
@@ -4643,6 +4697,154 @@ REGOLE CRITICHE:
         return;
       }
 
+      // POST /api/studio/webcraft/snapshot  { projectName } → { ok, snapshot }
+      // Creates a timestamped snapshot of all project files (excludes node_modules)
+      if (pathname === '/api/studio/webcraft/snapshot' && method === 'POST') {
+        const body = await parseBody(req);
+        const projName = (body.projectName || '').replace(/[^a-zA-Z0-9_-]/g, '');
+        if (!projName) { sendJSON(res, 400, { error: 'projectName required' }); return; }
+        const projDir = path.join(os.homedir(), '.nha', 'webcraft', projName);
+        const snapDir = path.join(projDir, '.snapshots');
+        if (!fs.existsSync(snapDir)) fs.mkdirSync(snapDir, { recursive: true });
+        const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const snapPath = path.join(snapDir, ts + '.json');
+        const snapshot = {};
+        const walkSnap = (dir, base) => {
+          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name === '.snapshots' || entry.name.startsWith('.')) continue;
+            const rel = base ? base + '/' + entry.name : entry.name;
+            if (entry.isDirectory()) { walkSnap(path.join(dir, entry.name), rel); }
+            else {
+              try { snapshot[rel] = fs.readFileSync(path.join(dir, entry.name), 'utf8'); } catch(_) {}
+            }
+          }
+        };
+        walkSnap(projDir, '');
+        fs.writeFileSync(snapPath, JSON.stringify({ ts, files: snapshot }), 'utf8');
+        // Keep only last 10 snapshots
+        const allSnaps = fs.readdirSync(snapDir).filter(f => f.endsWith('.json')).sort();
+        if (allSnaps.length > 10) {
+          for (const old of allSnaps.slice(0, allSnaps.length - 10)) {
+            try { fs.unlinkSync(path.join(snapDir, old)); } catch(_) {}
+          }
+        }
+        sendJSON(res, 200, { ok: true, snapshot: ts, fileCount: Object.keys(snapshot).length });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/studio/webcraft/snapshots/:name → { snapshots: [{ts, fileCount}] }
+      if (pathname.startsWith('/api/studio/webcraft/snapshots/') && method === 'GET') {
+        const projName = decodeURIComponent(pathname.replace('/api/studio/webcraft/snapshots/', '')).replace(/[^a-zA-Z0-9_-]/g, '');
+        const snapDir = path.join(os.homedir(), '.nha', 'webcraft', projName, '.snapshots');
+        if (!fs.existsSync(snapDir)) { sendJSON(res, 200, { snapshots: [] }); return; }
+        const snaps = fs.readdirSync(snapDir).filter(f => f.endsWith('.json')).sort().reverse().map(f => {
+          try {
+            const data = JSON.parse(fs.readFileSync(path.join(snapDir, f), 'utf8'));
+            return { ts: data.ts, fileCount: Object.keys(data.files || {}).length };
+          } catch(_) { return null; }
+        }).filter(Boolean);
+        sendJSON(res, 200, { snapshots: snaps });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/studio/webcraft/restore  { projectName, ts } → { ok, restored }
+      if (pathname === '/api/studio/webcraft/restore' && method === 'POST') {
+        const body = await parseBody(req);
+        const projName = (body.projectName || '').replace(/[^a-zA-Z0-9_-]/g, '');
+        const ts = (body.ts || '').replace(/[^0-9T\-]/g, '');
+        if (!projName || !ts) { sendJSON(res, 400, { error: 'projectName and ts required' }); return; }
+        const snapPath = path.join(os.homedir(), '.nha', 'webcraft', projName, '.snapshots', ts + '.json');
+        if (!fs.existsSync(snapPath)) { sendJSON(res, 404, { error: 'snapshot not found' }); return; }
+        const data = JSON.parse(fs.readFileSync(snapPath, 'utf8'));
+        const projDir = path.join(os.homedir(), '.nha', 'webcraft', projName);
+        let restored = 0;
+        for (const [rel, content] of Object.entries(data.files || {})) {
+          const fp = path.join(projDir, rel);
+          fs.mkdirSync(path.dirname(fp), { recursive: true });
+          fs.writeFileSync(fp, content, 'utf8');
+          restored++;
+        }
+        sendJSON(res, 200, { ok: true, restored });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/studio/webcraft/syntax-check  { projectName } → { results: [{file, ok, error}] }
+      if (pathname === '/api/studio/webcraft/syntax-check' && method === 'POST') {
+        const body = await parseBody(req);
+        const projName = (body.projectName || '').replace(/[^a-zA-Z0-9_-]/g, '');
+        if (!projName) { sendJSON(res, 400, { error: 'projectName required' }); return; }
+        const projDir = path.join(os.homedir(), '.nha', 'webcraft', projName);
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        const jsFiles = [];
+        const walkJs = (dir, base) => {
+          if (!fs.existsSync(dir)) return;
+          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+            const rel = base ? base + '/' + entry.name : entry.name;
+            if (entry.isDirectory()) { walkJs(path.join(dir, entry.name), rel); }
+            else if (entry.name.endsWith('.js') || entry.name.endsWith('.mjs')) { jsFiles.push(rel); }
+          }
+        };
+        walkJs(projDir, '');
+        const results = [];
+        for (const rel of jsFiles) {
+          const fp = path.join(projDir, rel);
+          try {
+            await execFileAsync(process.execPath, ['--check', fp], { timeout: 5000 });
+            results.push({ file: rel, ok: true });
+          } catch(e) {
+            const errMsg = (e.stderr || e.message || '').split('\n')[0].replace(fp, rel);
+            results.push({ file: rel, ok: false, error: errMsg });
+          }
+        }
+        sendJSON(res, 200, { results });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/studio/webcraft/grep  { projectName, query } → { matches: [{file, line, lineNum, match}] }
+      if (pathname === '/api/studio/webcraft/grep' && method === 'POST') {
+        const body = await parseBody(req);
+        const projName = (body.projectName || '').replace(/[^a-zA-Z0-9_-]/g, '');
+        const query = (body.query || '').slice(0, 200);
+        if (!projName || !query) { sendJSON(res, 400, { error: 'projectName and query required' }); return; }
+        const projDir = path.join(os.homedir(), '.nha', 'webcraft', projName);
+        const matches = [];
+        let queryRe;
+        try { queryRe = new RegExp(query, 'gi'); } catch(_) { queryRe = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'); }
+        const walkGrep = (dir, base) => {
+          if (!fs.existsSync(dir)) return;
+          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+            const rel = base ? base + '/' + entry.name : entry.name;
+            if (entry.isDirectory()) { walkGrep(path.join(dir, entry.name), rel); }
+            else {
+              const ext = entry.name.split('.').pop();
+              if (!['js','mjs','ts','html','css','json','md','sql','env','conf'].includes(ext)) continue;
+              try {
+                const lines = fs.readFileSync(path.join(dir, entry.name), 'utf8').split('\n');
+                lines.forEach((line, idx) => {
+                  queryRe.lastIndex = 0;
+                  if (queryRe.test(line)) {
+                    matches.push({ file: rel, lineNum: idx + 1, line: line.trim().slice(0, 200) });
+                    if (matches.length >= 100) return;
+                  }
+                });
+              } catch(_) {}
+            }
+          }
+        };
+        walkGrep(projDir, '');
+        sendJSON(res, 200, { matches: matches.slice(0, 100) });
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // ── Studio: Parliament deliberation (SSE streaming) ──────────────────
       // Implements the Legion DeliberationEngine protocol adapted for Studio:
       // Round 1 outputs already exist (from normal workflow steps).

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 = '13.5.56';
+export const VERSION = '13.5.58';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';