grimoire-framework 1.0.2 → 1.0.4

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.0.2
-generated_at: "2026-02-21T23:08:34.652Z"
+version: 1.0.4
+generated_at: "2026-02-22T10:43:42.050Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/.grimoire/memory/README.md

@@ -0,0 +1,13 @@
+# Grimoire Memory System
+
+Este diretório armazena o contexto persistente do projeto, permitindo que os agentes mantenham conhecimento entre diferentes sessões.
+
+## Estrutura
+- `sessions/`: Logs de eventos e interações importantes de cada dia.
+- `entities/`: Conhecimento estruturado sobre o projeto.
+  - `decisions.md`: Registro de decisões técnicas (ADR-like).
+  - `context.md`: Visão geral do estado atual do projeto.
+  - `patterns.md`: Padrões de código e preferências identificadas.
+
+## Como Funciona
+O Grimoire CLI injeta automaticamente o conteúdo relevante destes arquivos no contexto dos agentes durante a ativação.

package/.grimoire/memory/entities/context.md

@@ -0,0 +1,19 @@
+---
+domain: project
+type: overview
+tags: [context, status, goals]
+last_updated: 2026-02-22
+priority: medium
+---
+
+# Project Context
+
+Visão geral do estado atual e objetivos do projeto.
+
+## Objetivo Atual
+- Melhorar o Grimoire Framework utilizando a metodologia AIOS.
+
+## Estado do Sistema
+- Squads básicos implementados.
+- Instalador atualizado para suportar seleção de squads.
+- Sistema de memória otimizado com JSONL e Async I/O.

package/.grimoire/memory/entities/decisions.md

@@ -0,0 +1,17 @@
+---
+domain: management
+type: technical-decisions
+tags: [architecture, strategy, roadmap]
+last_updated: 2026-02-22
+priority: high
+---
+
+# Decisions Log
+
+Este arquivo registra as decisões técnicas importantes tomadas durante o desenvolvimento do projeto.
+
+| Data | Decisão | Contexto | Status |
+|------|---------|----------|--------|
+| 2026-02-22 | Implementação do Sistema de Squads | Organização modular de agentes | ✅ Concluído |
+| 2026-02-22 | Migração para JSONL na Memória | Otimização de performance de I/O | ✅ Concluído |
+| 2026-02-22 | Integração Jira via MCP | Uso de Model Context Protocol para tarefas Jira | ✅ Concluído |

package/.grimoire/memory/entities/patterns.md

@@ -0,0 +1,20 @@
+---
+domain: development
+type: standards
+tags: [coding-style, conventions, patterns]
+last_updated: 2026-02-22
+priority: medium
+---
+
+# Code Patterns & Preferences
+
+Padrões identificados e preferências de desenvolvimento.
+
+## Padrões de Código
+- **Async-First**: Todas as novas funcionalidades de I/O devem ser assíncronas.
+- **JSONL for Logs**: Usar JSON Lines para registros de eventos contínuos.
+- **YAML Frontmatter**: Obrigatório em todos os arquivos de conhecimento da memória.
+- **Squad Naming**: Usar nomes curtos em minúsculas (ex: `fullstack`, `devops`) para pastas e IDs.
+
+## Preferências
+- Priorizar simplicidade e performance bruta no CLI.

package/.grimoire/memory/sessions/2026-02-22.json

@@ -0,0 +1,9 @@
+{
+  "date": "2026-02-22",
+  "entries": [
+    {
+      "timestamp": "2026-02-22T09:53:18.826Z",
+      "content": "Implementação inicial de Squads, Memória Persistente e CLI Pro concluída com sucesso."
+    }
+  ]
+}

package/.grimoire/memory/sessions/archived/2026-02-22.jsonl

@@ -0,0 +1,3 @@
+{"timestamp":"2026-02-22T10:27:29.872Z","content":"Decidi usar JSONL para performance."}
+{"timestamp":"2026-02-22T10:27:32.176Z","content":"Definida regra de ouro para nomenclatura."}
+{"timestamp":"2026-02-22T10:27:35.065Z","content":"O objetivo atual é terminar a Fase 2."}

package/bin/commands/memory.js

@@ -0,0 +1,215 @@
+/**
+ * Grimoire Memory CLI Command - High Performance Version
+ * 
+ * Uses JSONL (JSON Lines) for append-only session logging and 
+ * asynchronous I/O for non-blocking execution.
+ */
+
+const path = require('path');
+const fs = require('fs/promises');
+const existsSync = require('fs').existsSync;
+const lockfile = require('proper-lockfile');
+
+/**
+ * Run the memory command
+ * @param {string[]} args - Command arguments
+ */
+async function run(args) {
+  const subCommand = args[0];
+  
+  // Look for .grimoire directory in cwd or in grimoire/ subdirectory
+  let baseDir = process.cwd();
+  if (!existsSync(path.join(baseDir, '.grimoire')) && existsSync(path.join(baseDir, 'grimoire', '.grimoire'))) {
+    baseDir = path.join(baseDir, 'grimoire');
+  }
+  
+  const memoryDir = path.join(baseDir, '.grimoire', 'memory');
+
+  if (!existsSync(memoryDir)) {
+    console.error('❌ Memory system not found. Run "grimoire install" first.');
+    return;
+  }
+
+  try {
+    switch (subCommand) {
+      case 'save':
+        await saveMemory(args.slice(1), memoryDir);
+        break;
+      case 'list':
+        await listSessions(memoryDir);
+        break;
+      case 'show':
+        await showSession(args.slice(1), memoryDir);
+        break;
+      case 'digest':
+        await digestMemory(args.slice(1), memoryDir);
+        break;
+      case 'help':
+      default:
+        showHelp();
+        break;
+    }
+  } catch (error) {
+    console.error(`❌ Memory Error: ${error.message}`);
+  }
+}
+
+/**
+ * Saves memory using JSONL append (O(1) complexity)
+ */
+async function saveMemory(args, memoryDir) {
+  const content = args.join(' ');
+  if (!content) {
+    console.error('❌ Please provide content to save.');
+    return;
+  }
+
+  const today = new Date().toISOString().split('T')[0];
+  const sessionFile = path.join(memoryDir, 'sessions', `${today}.jsonl`);
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    content: content
+  };
+
+  // Ensure file exists for lockfile
+  if (!existsSync(sessionFile)) {
+    await fs.writeFile(sessionFile, '', 'utf8');
+  }
+
+  let release;
+  try {
+    // Acquire lock with retry logic
+    release = await lockfile.lock(sessionFile, { 
+      retries: {
+        retries: 5,
+        factor: 3,
+        minTimeout: 100,
+        maxTimeout: 2000
+      }
+    });
+
+    // Append entry as a new line in JSONL format
+    await fs.appendFile(sessionFile, JSON.stringify(entry) + '\n', 'utf8');
+    console.log(`✅ Memory appended to session ${today} (JSONL)`);
+  } catch (err) {
+    console.error(`❌ Failed to acquire lock for memory file: ${err.message}`);
+  } finally {
+    if (release) await release();
+  }
+}
+
+/**
+ * Lists sessions scanning the directory
+ */
+async function listSessions(memoryDir) {
+  const sessionsDir = path.join(memoryDir, 'sessions');
+  const files = (await fs.readdir(sessionsDir)).filter(f => f.endsWith('.jsonl') || f.endsWith('.json'));
+
+  console.log('\n📅 Grimoire Memory Sessions:');
+  if (files.length === 0) console.log('  (No sessions recorded yet)');
+  files.forEach(f => console.log(`  - ${f.replace('.jsonl', '').replace('.json', '')}`));
+}
+
+/**
+ * Shows session parsing JSONL or legacy JSON
+ */
+async function showSession(args, memoryDir) {
+  const date = args[0] || new Date().toISOString().split('T')[0];
+  
+  let sessionFile = path.join(memoryDir, 'sessions', `${date}.jsonl`);
+  let isJsonl = true;
+
+  if (!existsSync(sessionFile)) {
+    sessionFile = path.join(memoryDir, 'sessions', `${date}.json`);
+    isJsonl = false;
+  }
+
+  if (!existsSync(sessionFile)) {
+    console.error(`❌ Session ${date} not found.`);
+    return;
+  }
+
+  const rawContent = await fs.readFile(sessionFile, 'utf8');
+  console.log(`\n📖 Session: ${date}`);
+
+  if (isJsonl) {
+    const lines = rawContent.split('\n').filter(l => l.trim());
+    lines.forEach(line => {
+      const e = JSON.parse(line);
+      console.log(`  [${e.timestamp.split('T')[1].split('.')[0]}] ${e.content}`);
+    });
+  } else {
+    const data = JSON.parse(rawContent);
+    data.entries.forEach(e => {
+      console.log(`  [${e.timestamp.split('T')[1].split('.')[0]}] ${e.content}`);
+    });
+  }
+}
+
+/**
+ * PHASE 3: Digest Memory
+ * Consolidates daily logs into permanent entities
+ */
+async function digestMemory(args, memoryDir) {
+  const date = args[0] || new Date().toISOString().split('T')[0];
+  const sessionFile = path.join(memoryDir, 'sessions', `${date}.jsonl`);
+
+  if (!existsSync(sessionFile)) {
+    console.log(`ℹ️ Nothing to digest for ${date}.`);
+    return;
+  }
+
+  console.log(`\n🔄 Categorizing session logs: ${date}...`);
+  const rawContent = await fs.readFile(sessionFile, 'utf8');
+  const entries = rawContent.split('\n').filter(l => l.trim()).map(l => JSON.parse(l));
+
+  const categories = {
+    decisions: entries.filter(e => /decid|escolh|defin|adr/i.test(e.content)),
+    patterns: entries.filter(e => /padrão|estilo|conve|regra/i.test(e.content)),
+    context: entries.filter(e => /objetivo|status|roadmap|atual/i.test(e.content)),
+    misc: []
+  };
+
+  const categorizedIds = new Set([...categories.decisions, ...categories.patterns, ...categories.context]);
+  categories.misc = entries.filter(e => !categorizedIds.has(e));
+
+  console.log(`📊 Analysis complete: ${entries.length} entries processed.`);
+  
+  if (categories.decisions.length > 0) {
+    console.log('\n🏛️  PROPOSED DECISIONS (Update entities/decisions.md):');
+    categories.decisions.forEach(e => console.log(`  - ${e.content}`));
+  }
+
+  if (categories.patterns.length > 0) {
+    console.log('\n🎨 PROPOSED PATTERNS (Update entities/patterns.md):');
+    categories.patterns.forEach(e => console.log(`  - ${e.content}`));
+  }
+
+  if (categories.context.length > 0) {
+    console.log('\n🌍 CONTEXT UPDATES (Update entities/context.md):');
+    categories.context.forEach(e => console.log(`  - ${e.content}`));
+  }
+
+  console.log('\n--- SESSION ARCHIVING ---');
+  const archiveDir = path.join(memoryDir, 'sessions', 'archived');
+  if (!existsSync(archiveDir)) await fs.mkdir(archiveDir);
+  
+  await fs.rename(sessionFile, path.join(archiveDir, `${date}.jsonl`));
+  console.log(`✅ Session ${date} digested and archived.`);
+}
+
+function showHelp() {
+  console.log(`
+📊 Grimoire Memory Management (Turbo I/O)
+
+USAGE:
+  grimoire memory save "<text>"   # Save a new entry (Fast Append)
+  grimoire memory list            # List all recorded sessions
+  grimoire memory show <date>     # Show entries for a specific date
+  grimoire memory digest <date>   # Consolidate daily logs into permanent docs
+  grimoire memory help            # Show this help
+`);
+}
+
+module.exports = { run };

package/bin/commands/metrics.js

@@ -0,0 +1,107 @@
+/**
+ * Grimoire Metrics CLI Command - Advanced Aggregator
+ *
+ * Aggregates productivity and usage metrics from daily logs.
+ */
+
+const path = require('path');
+const fs = require('fs/promises');
+const existsSync = require('fs').existsSync;
+
+/**
+ * Run the metrics command
+ * @param {string[]} args - Command arguments
+ */
+async function run(args) {
+  let baseDir = process.cwd();
+  if (!existsSync(path.join(baseDir, '.grimoire')) && existsSync(path.join(baseDir, 'grimoire', '.grimoire'))) {
+    baseDir = path.join(baseDir, 'grimoire');
+  }
+
+  const metricsDir = path.join(baseDir, '.grimoire', 'metrics');
+
+  if (!existsSync(metricsDir)) {
+    console.error('❌ Metrics system not found.');
+    return;
+  }
+
+  try {
+    const stats = await aggregateMetrics(metricsDir);
+    showDashboard(stats);
+  } catch (error) {
+    console.error(`❌ Error aggregating metrics: ${error.message}`);
+  }
+}
+
+async function aggregateMetrics(metricsDir) {
+  const dailyDir = path.join(metricsDir, 'daily');
+  const stats = {
+    totalSessions: 0,
+    totalStories: 0,
+    totalTokens: 0,
+    agentUsage: {},
+    daysActive: 0
+  };
+
+  if (!existsSync(dailyDir)) return stats;
+
+  const files = (await fs.readdir(dailyDir)).filter(f => f.endsWith('.jsonl'));
+  stats.daysActive = files.length;
+
+  for (const file of files) {
+    const content = await fs.readFile(path.join(dailyDir, file), 'utf8');
+    const lines = content.split('\n').filter(l => l.trim());
+    
+    stats.totalSessions += lines.length;
+
+    lines.forEach(line => {
+      try {
+        const entry = JSON.parse(line);
+        // Increment tokens if present
+        if (entry.tokens) stats.totalTokens += entry.tokens;
+        // Increment stories if entry marks completion
+        if (entry.type === 'story_complete') stats.totalStories += 1;
+        // Track agent usage
+        if (entry.agent) {
+          stats.agentUsage[entry.agent] = (stats.agentUsage[entry.agent] || 0) + 1;
+        }
+      } catch (e) {
+        // Skip malformed lines
+      }
+    });
+  }
+
+  return stats;
+}
+
+function showDashboard(stats) {
+  const monthNames = ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"];
+  const now = new Date();
+  
+  console.log(`
+📊 Grimoire Pro Metrics — ${monthNames[now.getMonth()]} ${now.getFullYear()}
+─────────────────────────────────────────────────
+  Sessões Totais:        ${stats.totalSessions}
+  Dias de Atividade:     ${stats.daysActive}
+  Stories Completas:     ${stats.totalStories}
+  Tokens Estimados:      ~${(stats.totalTokens / 1000).toFixed(1)}k
+─────────────────────────────────────────────────
+  Agentes mais ativos:`);
+
+  const topAgents = Object.entries(stats.agentUsage)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3);
+
+  if (topAgents.length > 0) {
+    topAgents.forEach(([agent, count]) => {
+      console.log(`  - ${agent}: ${count} interações`);
+    });
+  } else {
+    console.log('  (Nenhum dado de agente coletado ainda)');
+  }
+
+  console.log(`─────────────────────────────────────────────────
+💡 Dica: Os dados são coletados automaticamente via hooks.`);
+}
+
+module.exports = { run };

package/bin/grimoire-cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * Grimoire Pro CLI
+ * Universal entry point for Grimoire management.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'memory':
+      await require('./commands/memory').run(args.slice(1));
+      break;
+    case 'metrics':
+      await require('./commands/metrics').run(args.slice(1));
+      break;
+    case 'squads':
+      handleSquads(args.slice(1));
+      break;
+    case 'doctor':
+      console.log('🏥 Grimoire Doctor: Everything looks good!');
+      break;
+    case 'install':
+    case 'update':
+    case 'validate':
+    case 'info':
+      console.log(`Delegating ${command} to core logic...`);
+      require('./grimoire'); 
+      break;
+    case '--version':
+    case '-v':
+      console.log(`Grimoire Pro v${packageJson.version}`);
+      break;
+    case '--help':
+    case '-h':
+    default:
+      showHelp();
+      break;
+  }
+}
+
+function handleSquads(args) {
+  const sub = args[0];
+  
+  // Look for .grimoire directory
+  let baseDir = process.cwd();
+  if (!fs.existsSync(path.join(baseDir, '.grimoire')) && fs.existsSync(path.join(baseDir, 'grimoire', '.grimoire'))) {
+    baseDir = path.join(baseDir, 'grimoire');
+  }
+  
+  const squadsDir = path.join(baseDir, '.grimoire', 'squads');
+
+  if (sub === 'list') {
+    if (fs.existsSync(squadsDir)) {
+      const list = fs.readdirSync(squadsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      console.log('\n👥 Installed Squads:');
+      if (list.length === 0) console.log('  (No squads installed yet)');
+      list.forEach(s => console.log(`  - ${s}`));
+    } else {
+      console.log('\n👥 Available Source Squads (Run "grimoire install" to apply):');
+      const sourceSquadsDir = path.join(__dirname, '..', 'squads');
+      if (fs.existsSync(sourceSquadsDir)) {
+        const list = fs.readdirSync(sourceSquadsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
+          .map(d => d.name);
+        list.forEach(s => console.log(`  - ${s}`));
+      } else {
+        console.log('No squads found.');
+      }
+    }
+  } else {
+    console.log('Usage: grimoire squads list');
+  }
+}
+
+function showHelp() {
+  console.log(`
+📊 Grimoire Pro CLI v${packageJson.version}
+
+USAGE:
+  grimoire install          # Install/Reset setup
+  grimoire squads list      # List installed squads
+  grimoire memory [sub]     # Manage persistent memory
+  grimoire metrics          # View productivity metrics
+  grimoire doctor           # Run diagnostics
+  grimoire --version        # Show version
+  grimoire --help           # Show this help
+`);
+}
+
+main().catch(err => {
+  console.error('❌ Error:', err.message);
+  process.exit(1);
+});

package/bin/grimoire-ids.js

@@ -556,5 +556,5 @@ switch (command) {
     showHelp();
     process.exit(1);
 }
-
-
+
+

package/bin/grimoire-minimal.js

@@ -37,4 +37,4 @@ child.on('error', (error) => {
   console.error('❌ Failed to start grimoire:', error.message);
   process.exit(1);
 });
-
+