grimoire-framework 1.4.1 → 1.5.0

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.4.1
-generated_at: "2026-02-22T17:28:34.901Z"
+version: 1.5.0
+generated_at: "2026-02-22T17:38:38.314Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/bin/commands/context.js

@@ -0,0 +1,319 @@
+/**
+ * grimoire context — Live Context Manager
+ *
+ * grimoire context update     Regenera CONTEXT.md a partir de todos os .jsonl
+ * grimoire context show       Exibe CONTEXT.md no terminal
+ * grimoire context clean       Remove arquivos context/ gerados
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+function findGrimoireDir() {
+    const cwd = process.cwd();
+    const direct = path.join(cwd, '.grimoire');
+    const sub = path.join(cwd, 'grimoire', '.grimoire');
+    if (fs.existsSync(direct)) return direct;
+    if (fs.existsSync(sub)) return sub;
+    return null;
+}
+
+function getGlobalMemoryDir() {
+    const d = path.join(os.homedir(), '.grimoire', 'memory');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+function getContextDir(grimoireDir) {
+    const d = path.join(grimoireDir, 'context');
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+
+// ── Load all memory entries ───────────────────────────────────────────────────
+function loadAllEntries(grimoireDir, includeGlobal = true) {
+    const entries = [];
+
+    // Local sessions
+    const sessionsDir = path.join(grimoireDir, 'memory', 'sessions');
+    if (fs.existsSync(sessionsDir)) {
+        for (const f of fs.readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl')).sort()) {
+            const raw = fs.readFileSync(path.join(sessionsDir, f), 'utf8');
+            for (const line of raw.split('\n').filter(l => l.trim())) {
+                try { entries.push({ ...JSON.parse(line), date: f.slice(0, 10), source: 'local' }); } catch (_) { }
+            }
+        }
+    }
+
+    // Pinned (local)
+    const pinnedFile = path.join(grimoireDir, 'memory', 'pinned.jsonl');
+    if (fs.existsSync(pinnedFile)) {
+        const raw = fs.readFileSync(pinnedFile, 'utf8');
+        for (const line of raw.split('\n').filter(l => l.trim())) {
+            try { entries.push({ ...JSON.parse(line), source: 'pinned' }); } catch (_) { }
+        }
+    }
+
+    // Global
+    if (includeGlobal) {
+        const globalFile = path.join(getGlobalMemoryDir(), 'global.jsonl');
+        if (fs.existsSync(globalFile)) {
+            const raw = fs.readFileSync(globalFile, 'utf8');
+            for (const line of raw.split('\n').filter(l => l.trim())) {
+                try { entries.push({ ...JSON.parse(line), source: 'global' }); } catch (_) { }
+            }
+        }
+    }
+
+    return entries;
+}
+
+// ── Build Markdown files ──────────────────────────────────────────────────────
+function buildContextMd(entries) {
+    const now = new Date().toISOString().split('T')[0];
+    const pinned = entries.filter(e => e.source === 'pinned');
+    const recent = entries.filter(e => e.source !== 'pinned').slice(-20).reverse();
+    const globals = entries.filter(e => e.source === 'global').slice(-10).reverse();
+
+    const lines = [];
+    lines.push(`# 🧠 Contexto do Projeto\n`);
+    lines.push(`> Auto-gerado em ${now} via \`grimoire context update\`\n`);
+
+    if (pinned.length) {
+        lines.push(`## 📌 Fixadas\n`);
+        pinned.forEach(e => lines.push(`- ${e.content}`));
+        lines.push('');
+    }
+
+    const decisions = recent.filter(e => e.tag === 'decisão' || e.tag === 'decisao' || e.tag === 'decision');
+    if (decisions.length) {
+        lines.push(`## ✅ Últimas Decisões\n`);
+        decisions.slice(0, 8).forEach(e => lines.push(`- **${e.date || ''}** ${e.content}`));
+        lines.push('');
+    }
+
+    const patterns = recent.filter(e => e.tag === 'padrão' || e.tag === 'padrao' || e.tag === 'pattern');
+    if (patterns.length) {
+        lines.push(`## 🔧 Padrões Estabelecidos\n`);
+        patterns.slice(0, 8).forEach(e => lines.push(`- **${e.date || ''}** ${e.content}`));
+        lines.push('');
+    }
+
+    const other = recent.filter(e => !['decisão', 'decisao', 'decision', 'padrão', 'padrao', 'pattern'].includes(e.tag));
+    if (other.length) {
+        lines.push(`## 📝 Entradas Recentes\n`);
+        other.slice(0, 10).forEach(e => {
+            const tag = e.tag ? ` \`#${e.tag}\`` : '';
+            const src = e.source === 'global' ? ' 🌐' : '';
+            lines.push(`- **${e.date || ''}** ${e.content}${tag}${src}`);
+        });
+        lines.push('');
+    }
+
+    if (globals.length) {
+        lines.push(`## 🌐 Memória Global (cross-projeto)\n`);
+        globals.slice(0, 5).forEach(e => {
+            const tag = e.tag ? ` \`#${e.tag}\`` : '';
+            lines.push(`- ${e.content}${tag}`);
+        });
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+function buildTagMd(entries, tag, title, emoji) {
+    const variants = [tag, tag.normalize('NFD').replace(/[\u0300-\u036f]/g, '')];
+    const filtered = entries.filter(e => variants.includes(e.tag)).slice(-30).reverse();
+    if (!filtered.length) return null;
+
+    const lines = [`# ${emoji} ${title}\n`, `> Auto-gerado pelo Grimoire\n`];
+    filtered.forEach(e => {
+        const src = e.source === 'global' ? ' 🌐' : '';
+        lines.push(`- **${e.date || ''}** ${e.content}${src}`);
+    });
+    return lines.join('\n');
+}
+
+// ── Inject into GEMINI.md ─────────────────────────────────────────────────────
+const MARKER_START = '<!-- grimoire-MANAGED-START: memory-context -->';
+const MARKER_END = '<!-- grimoire-MANAGED-END: memory-context -->';
+
+function buildGeminiBlock(entries) {
+    const now = new Date().toISOString().split('T')[0];
+    const pinned = entries.filter(e => e.source === 'pinned');
+    const recent = entries.filter(e => e.source !== 'pinned').slice(-15).reverse();
+    const decisions = recent.filter(e => ['decisão', 'decisao', 'decision'].includes(e.tag)).slice(0, 5);
+    const patterns = recent.filter(e => ['padrão', 'padrao', 'pattern'].includes(e.tag)).slice(0, 5);
+
+    const block = [];
+    block.push(MARKER_START);
+    block.push(`## 🧠 Contexto do Projeto (auto-gerado)\n`);
+
+    if (pinned.length) {
+        block.push(`### 📌 Fixadas\n`);
+        pinned.forEach(e => block.push(`- ${e.content}`));
+        block.push('');
+    }
+
+    if (decisions.length) {
+        block.push(`### ✅ Últimas decisões\n`);
+        decisions.forEach(e => block.push(`- ${e.date}: ${e.content}`));
+        block.push('');
+    }
+
+    if (patterns.length) {
+        block.push(`### 🔧 Padrões\n`);
+        patterns.forEach(e => block.push(`- ${e.date}: ${e.content}`));
+        block.push('');
+    }
+
+    // Any other recent entries without special tag
+    const others = recent.filter(e => !['decisão', 'decisao', 'decision', 'padrão', 'padrao', 'pattern'].includes(e.tag)).slice(0, 5);
+    if (others.length) {
+        block.push(`### 📝 Recentes\n`);
+        others.forEach(e => {
+            const tag = e.tag ? ` [#${e.tag}]` : '';
+            block.push(`- ${e.date}: ${e.content}${tag}`);
+        });
+        block.push('');
+    }
+
+    block.push(`> _Atualizado em ${now}. Use \`grimoire context update\` para regenerar._`);
+    block.push(MARKER_END);
+    return block.join('\n');
+}
+
+function injectIntoGeminiMd(grimoireDir, entries) {
+    // GEMINI.md can be at project root or parent
+    const cwd = process.cwd();
+    const candidates = [
+        path.join(cwd, 'GEMINI.md'),
+        path.join(path.dirname(grimoireDir), 'GEMINI.md'),
+    ];
+    const geminiPath = candidates.find(p => fs.existsSync(p));
+    if (!geminiPath) return false;
+
+    const original = fs.readFileSync(geminiPath, 'utf8');
+    const newBlock = buildGeminiBlock(entries);
+
+    let updated;
+    if (original.includes(MARKER_START)) {
+        // Replace existing block
+        const re = new RegExp(`${regEscape(MARKER_START)}[\\s\\S]*?${regEscape(MARKER_END)}`, 'g');
+        updated = original.replace(re, newBlock);
+    } else {
+        // Append before last ---
+        const lastHr = original.lastIndexOf('\n---');
+        if (lastHr !== -1) {
+            updated = original.slice(0, lastHr) + '\n\n' + newBlock + '\n' + original.slice(lastHr);
+        } else {
+            updated = original + '\n\n' + newBlock + '\n';
+        }
+    }
+
+    if (updated !== original) {
+        fs.writeFileSync(geminiPath, updated, 'utf8');
+        return true;
+    }
+    return false;
+}
+
+function regEscape(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ── Core update logic ─────────────────────────────────────────────────────────
+function doUpdate(grimoireDir, silent = false) {
+    const contextDir = getContextDir(grimoireDir);
+    const entries = loadAllEntries(grimoireDir, true);
+
+    // CONTEXT.md
+    fs.writeFileSync(path.join(contextDir, 'CONTEXT.md'), buildContextMd(entries), 'utf8');
+
+    // decisions.md
+    const dec = buildTagMd(entries, 'decisão', 'Decisões', '✅') ||
+        buildTagMd(entries, 'decisao', 'Decisões', '✅') ||
+        buildTagMd(entries, 'decision', 'Decisões', '✅');
+    if (dec) fs.writeFileSync(path.join(contextDir, 'decisions.md'), dec, 'utf8');
+
+    // patterns.md
+    const pat = buildTagMd(entries, 'padrão', 'Padrões', '🔧') ||
+        buildTagMd(entries, 'padrao', 'Padrões', '🔧') ||
+        buildTagMd(entries, 'pattern', 'Padrões', '🔧');
+    if (pat) fs.writeFileSync(path.join(contextDir, 'patterns.md'), pat, 'utf8');
+
+    // pinned.md
+    const pinned = entries.filter(e => e.source === 'pinned');
+    if (pinned.length) {
+        const pinnedLines = ['# 📌 Memórias Fixadas\n', '> Estas entradas são sempre incluídas no contexto dos agentes.\n'];
+        pinned.forEach(e => pinnedLines.push(`- ${e.content}`));
+        fs.writeFileSync(path.join(contextDir, 'pinned.md'), pinnedLines.join('\n'), 'utf8');
+    }
+
+    // Inject GEMINI.md
+    const injected = injectIntoGeminiMd(grimoireDir, entries);
+
+    if (!silent) {
+        console.log('\n✅ Contexto atualizado!\n');
+        console.log(`   📄 .grimoire/context/CONTEXT.md`);
+        if (dec) console.log(`   ✅ .grimoire/context/decisions.md`);
+        if (pat) console.log(`   🔧 .grimoire/context/patterns.md`);
+        if (pinned.length) console.log(`   📌 .grimoire/context/pinned.md`);
+        if (injected) console.log(`   🔮 GEMINI.md atualizado com bloco memory-context`);
+        console.log(`\n   ${entries.length} entradas indexadas`);
+        console.log(`   grimoire context show  ← ver o resultado\n`);
+    }
+
+    return { entries, injected };
+}
+
+// ── run ───────────────────────────────────────────────────────────────────────
+function run(args) {
+    const sub = args[0] || 'update';
+
+    const grimoireDir = findGrimoireDir();
+    if (!grimoireDir) {
+        console.error('❌ .grimoire/ not found. Run: npx grimoire-framework install');
+        return;
+    }
+
+    switch (sub) {
+        case 'update':
+            doUpdate(grimoireDir);
+            break;
+
+        case 'show': {
+            const contextFile = path.join(grimoireDir, 'context', 'CONTEXT.md');
+            if (!fs.existsSync(contextFile)) {
+                console.log('\n⚠️  Contexto ainda não gerado. Rode: grimoire context update\n');
+                return;
+            }
+            console.log('\n' + fs.readFileSync(contextFile, 'utf8'));
+            break;
+        }
+
+        case 'clean': {
+            const contextDir = path.join(grimoireDir, 'context');
+            if (fs.existsSync(contextDir)) {
+                fs.readdirSync(contextDir).forEach(f => fs.unlinkSync(path.join(contextDir, f)));
+                console.log('\n✅ Arquivos de contexto removidos (.jsonl preservados)\n');
+            } else {
+                console.log('\nℹ️  Nada para limpar.\n');
+            }
+            break;
+        }
+
+        default:
+            console.log('\nUsage:\n');
+            console.log('  grimoire context update   Regenera CONTEXT.md + injeta GEMINI.md');
+            console.log('  grimoire context show     Exibe CONTEXT.md');
+            console.log('  grimoire context clean    Remove arquivos gerados\n');
+    }
+}
+
+module.exports = { run, doUpdate, loadAllEntries, getGlobalMemoryDir };

package/bin/commands/memory.js

@@ -23,7 +23,8 @@ async function run(args) {
     baseDir = path.join(baseDir, 'grimoire');
   }
 
-  const memoryDir = path.join(baseDir, '.grimoire', 'memory');
+  const grimoireDir = path.join(baseDir, '.grimoire');
+  const memoryDir = path.join(grimoireDir, 'memory');
 
   if (!existsSync(memoryDir)) {
     console.error('❌ Memory system not found. Run "grimoire install" first.');
@@ -33,7 +34,10 @@ async function run(args) {
   try {
     switch (subCommand) {
       case 'save':
-        await saveMemory(args.slice(1), memoryDir);
+        await saveMemory(args.slice(1), memoryDir, grimoireDir);
+        break;
+      case 'pin':
+        await pinMemory(args.slice(1), memoryDir, grimoireDir);
         break;
       case 'list-tags':
         await listTags(memoryDir);
@@ -66,10 +70,18 @@ async function run(args) {
   }
 }
 
+// ── Auto-update context (silent) ────────────────────────────────────────────
+function silentContextUpdate(grimoireDir) {
+  try {
+    const { doUpdate } = require('./context');
+    doUpdate(grimoireDir, true); // silent = true
+  } catch (_) { } // never block memory save
+}
+
 /**
  * Saves memory using JSONL append (O(1) complexity)
  */
-async function saveMemory(args, memoryDir) {
+async function saveMemory(args, memoryDir, grimoireDir) {
   // Extract --tag value if present
   const tagIdx = args.findIndex(a => a === '--tag' || a.startsWith('--tag='));
   let tag = null;
@@ -98,6 +110,10 @@ async function saveMemory(args, memoryDir) {
     }
   }
 
+  // Extract --global flag
+  const isGlobal = filteredArgs.includes('--global');
+  filteredArgs = filteredArgs.filter(a => a !== '--global');
+
   const content = filteredArgs.join(' ');
   if (!content) {
     console.error('❌ Please provide content to save.');
@@ -105,8 +121,6 @@ async function saveMemory(args, memoryDir) {
   }
 
   const today = new Date().toISOString().split('T')[0];
-  const sessionFile = path.join(memoryDir, 'sessions', `${today}.jsonl`);
-
   const entry = {
     timestamp: new Date().toISOString(),
     content: content,
@@ -114,6 +128,21 @@ async function saveMemory(args, memoryDir) {
     ...(storyId ? { story: storyId } : {}),
   };
 
+  if (isGlobal) {
+    // Save to global memory
+    const { getGlobalMemoryDir } = require('./context');
+    const globalDir = getGlobalMemoryDir();
+    const globalFile = require('path').join(globalDir, 'global.jsonl');
+    const fss = require('fs');
+    fss.appendFileSync(globalFile, JSON.stringify({ ...entry, source: 'global' }) + '\n', 'utf8');
+    const tagLabel = tag ? ` [#${tag}]` : '';
+    console.log(`✅ Memory saved globally 🌐${tagLabel}`);
+    silentContextUpdate(grimoireDir);
+    return;
+  }
+
+  const sessionFile = require('path').join(memoryDir, 'sessions', `${today}.jsonl`);
+
   // Ensure file exists for lockfile
   if (!existsSync(sessionFile)) {
     await fs.writeFile(sessionFile, '', 'utf8');
@@ -134,7 +163,10 @@ async function saveMemory(args, memoryDir) {
     // Append entry as a new line in JSONL format
     await fs.appendFile(sessionFile, JSON.stringify(entry) + '\n', 'utf8');
     const tagLabel = tag ? ` [#${tag}]` : '';
-    console.log(`✅ Memory appended to session ${today}${tagLabel}`);
+    const storyLabel = storyId ? ` [${storyId}]` : '';
+    console.log(`✅ Memory saved${tagLabel}${storyLabel}`);
+    // Auto-update .grimoire/context/ silently
+    silentContextUpdate(grimoireDir);
   } catch (err) {
     console.error(`❌ Failed to acquire lock for memory file: ${err.message}`);
   } finally {
@@ -142,6 +174,22 @@ async function saveMemory(args, memoryDir) {
   }
 }
 
+/**
+ * Pins a memory entry permanently in pinned.jsonl
+ */
+async function pinMemory(args, memoryDir, grimoireDir) {
+  const content = args.filter(a => !a.startsWith('-')).join(' ');
+  if (!content) {
+    console.log('Usage: grimoire memory pin "texto"\n');
+    return;
+  }
+  const pinnedFile = require('path').join(memoryDir, 'pinned.jsonl');
+  const entry = { timestamp: new Date().toISOString(), content, source: 'pinned' };
+  require('fs').appendFileSync(pinnedFile, JSON.stringify(entry) + '\n', 'utf8');
+  console.log(`📌 Memoria fixada: "${content}"`);
+  silentContextUpdate(grimoireDir);
+}
+
 /**
  * Lists sessions scanning the directory
  */

package/bin/grimoire-cli.js

@@ -151,6 +151,9 @@ async function main() {
     case 'export':
       require('./commands/exportall').run(args.slice(1));
       break;
+    case 'context':
+      require('./commands/context').run(args.slice(1));
+      break;
     case 'whoami':
       handleWhoami();
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grimoire-framework",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Grimoire: AI-Orchestrated System for Full Stack Development - Core Framework",
   "publishConfig": {
     "access": "public"