@grec0/memory-bank-mcp 0.1.1 → 0.1.2

package/dist/tools/initializeMemoryBank.js

@@ -0,0 +1,364 @@
+/**
+ * @fileoverview Initialize Memory Bank tool
+ * Creates the Memory Bank structure for a new project with initial templates
+ */
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Document templates for initialization
+ */
+const DOCUMENT_TEMPLATES = {
+    projectBrief: (projectName, description, date) => `# Project Brief
+
+## Project Overview
+- **Project Name**: ${projectName}
+- **Initialized**: ${date}
+- **Status**: Active
+
+## Description
+${description || "Project description pending. Update this section with the main purpose and goals of the project."}
+
+## Main Goals
+- [ ] Define project requirements
+- [ ] Establish architecture
+- [ ] Implement core features
+- [ ] Testing and deployment
+
+## Target Audience
+_Define who will use this project_
+
+## Project Type
+_Library / CLI Tool / Web App / API / Other_
+
+---
+*This document was auto-generated. Use \`memorybank_generate_project_docs\` with AI to create detailed documentation based on actual code analysis.*
+`,
+    productContext: (projectName, date) => `# Product Context
+
+## Purpose
+_Why does this project exist? What problem does it solve?_
+
+## User Stories
+- As a user, I want to...
+- As a developer, I want to...
+
+## Key Features
+1. Feature 1 - Description
+2. Feature 2 - Description
+3. Feature 3 - Description
+
+## Business Logic
+_Key business rules and workflows_
+
+## Integration Points
+- External APIs
+- Services
+- Databases
+
+## Data Models
+_Key entities and their relationships_
+
+---
+*Last updated: ${date}*
+*Use \`memorybank_generate_project_docs\` to generate detailed product context from code analysis.*
+`,
+    systemPatterns: (projectName, date) => `# System Patterns
+
+## Architecture Style
+_MVC / Microservices / Monolith / Serverless / Other_
+
+## Design Patterns Used
+- Pattern 1: Description and usage
+- Pattern 2: Description and usage
+
+## Code Organization
+\`\`\`
+src/
+├── components/    # Description
+├── services/      # Description
+├── utils/         # Description
+└── ...
+\`\`\`
+
+## Naming Conventions
+- Files: kebab-case / camelCase / PascalCase
+- Functions: camelCase
+- Classes: PascalCase
+- Constants: UPPER_SNAKE_CASE
+
+## Error Handling Strategy
+_How errors are managed across the codebase_
+
+## State Management
+_How state is handled (if applicable)_
+
+---
+*Last updated: ${date}*
+*Use \`memorybank_generate_project_docs\` to auto-detect patterns from code analysis.*
+`,
+    techContext: (projectName, date) => `# Technical Context
+
+## Technology Stack
+
+### Languages
+- Language 1 (version)
+
+### Frameworks
+- Framework 1 (version)
+
+### Key Dependencies
+| Package | Version | Purpose |
+|---------|---------|---------|
+| package1 | x.x.x | Description |
+
+## Development Environment
+
+### Prerequisites
+- Node.js >= 18.0.0
+- Other requirements
+
+### Setup Commands
+\`\`\`bash
+npm install
+npm run build
+npm run dev
+\`\`\`
+
+### Environment Variables
+| Variable | Required | Description |
+|----------|----------|-------------|
+| VAR_NAME | Yes/No | Description |
+
+## Database / Storage
+_Data persistence solutions_
+
+## Testing
+- Framework: Jest / Mocha / Other
+- Coverage target: X%
+
+---
+*Last updated: ${date}*
+*Use \`memorybank_generate_project_docs\` to auto-detect tech stack from code analysis.*
+`,
+    activeContext: (projectName, date) => `# Active Context
+
+## Current Session
+- **Date**: ${date}
+- **Mode**: development
+- **Current Task**: Project initialization
+
+## Session History
+| Date | Mode | Task | Notes |
+|------|------|------|-------|
+| ${date} | development | Initialization | Memory Bank created |
+
+## Recent Changes
+- Memory Bank initialized for project "${projectName}"
+
+## Open Questions
+- What are the main goals for this project?
+- What is the target architecture?
+- Who is the target audience?
+
+## Next Steps
+- [ ] Index the codebase with \`memorybank_index_code\`
+- [ ] Generate detailed docs with \`memorybank_generate_project_docs\`
+- [ ] Define project requirements
+- [ ] Set up development environment
+
+## Active Considerations
+_Current technical considerations and trade-offs_
+
+---
+*Update this document with \`memorybank_update_context\` to track session progress.*
+`,
+    progress: (projectName, date) => `# Progress Tracking
+
+## Current Phase
+**Phase**: Initialization
+**Status**: In Progress
+**Started**: ${date}
+
+## Completed
+- [x] Repository setup
+- [x] Memory Bank initialization
+
+## In Progress
+- [ ] Environment configuration
+- [ ] Initial documentation
+- [ ] Code indexing
+
+## Upcoming
+- [ ] Core feature development
+- [ ] Testing setup
+- [ ] Documentation completion
+
+## Blockers
+_No blockers currently_
+
+## Milestones
+| Milestone | Status | Target Date | Notes |
+|-----------|--------|-------------|-------|
+| Project Setup | In Progress | - | Initial setup phase |
+| MVP | Pending | - | Minimum viable product |
+| v1.0 | Pending | - | First stable release |
+
+## Statistics
+- Files indexed: 0
+- Code chunks: 0
+- Last indexing: Never
+
+---
+*Update this document with \`memorybank_track_progress\` to track tasks and milestones.*
+`,
+    decisionLog: (projectName, date) => `# Decision Log
+
+This document tracks technical decisions made during the development of ${projectName}.
+
+## Recent Decisions
+
+### ${date} - Memory Bank Initialization
+**Decision**: Initialize Memory Bank for persistent project context
+
+**Rationale**: 
+- Enable AI agents to maintain context across sessions
+- Track technical decisions and their rationale
+- Monitor project progress systematically
+
+**Alternatives Considered**:
+- Manual documentation only
+- No persistent context tracking
+- External documentation tools
+
+**Impact**: Foundation for AI-assisted development with full project context
+
+---
+
+## Pending Decisions
+- Architecture style to adopt
+- Technology stack selection
+- Testing strategy
+
+## Decision Categories
+- 🏗️ Architecture
+- 💻 Technology
+- 📦 Dependencies
+- 🔧 Configuration
+- 📋 Process
+
+---
+*Record new decisions with \`memorybank_record_decision\` to maintain decision history.*
+`,
+};
+/**
+ * Initializes the Memory Bank structure for a project
+ */
+export async function initializeMemoryBank(params, storagePath = ".memorybank") {
+    const { projectId, projectPath, projectName, description } = params;
+    console.error(`\n=== Initializing Memory Bank ===`);
+    console.error(`Project ID: ${projectId}`);
+    console.error(`Project Path: ${projectPath}`);
+    const date = new Date().toISOString().split("T")[0];
+    const name = projectName || projectId;
+    const desc = description || "";
+    // Define docs path
+    const docsPath = path.join(storagePath, "projects", projectId, "docs");
+    // Check if already exists
+    const alreadyExists = fs.existsSync(docsPath);
+    if (alreadyExists) {
+        console.error(`Memory Bank already exists at: ${docsPath}`);
+        // Check which docs exist
+        const existingDocs = [];
+        const docFiles = [
+            "projectBrief.md",
+            "productContext.md",
+            "systemPatterns.md",
+            "techContext.md",
+            "activeContext.md",
+            "progress.md",
+            "decisionLog.md",
+        ];
+        for (const doc of docFiles) {
+            if (fs.existsSync(path.join(docsPath, doc))) {
+                existingDocs.push(doc);
+            }
+        }
+        return {
+            success: true,
+            message: `Memory Bank already initialized for project "${projectId}". ${existingDocs.length} documents exist.`,
+            projectId,
+            docsPath,
+            documentsCreated: [],
+            alreadyExists: true,
+        };
+    }
+    // Create directory structure
+    console.error(`Creating directory: ${docsPath}`);
+    fs.mkdirSync(docsPath, { recursive: true });
+    // Create all template documents
+    const documentsCreated = [];
+    const documents = {
+        "projectBrief.md": DOCUMENT_TEMPLATES.projectBrief(name, desc, date),
+        "productContext.md": DOCUMENT_TEMPLATES.productContext(name, date),
+        "systemPatterns.md": DOCUMENT_TEMPLATES.systemPatterns(name, date),
+        "techContext.md": DOCUMENT_TEMPLATES.techContext(name, date),
+        "activeContext.md": DOCUMENT_TEMPLATES.activeContext(name, date),
+        "progress.md": DOCUMENT_TEMPLATES.progress(name, date),
+        "decisionLog.md": DOCUMENT_TEMPLATES.decisionLog(name, date),
+    };
+    for (const [filename, content] of Object.entries(documents)) {
+        const filePath = path.join(docsPath, filename);
+        fs.writeFileSync(filePath, content, "utf-8");
+        documentsCreated.push(filename);
+        console.error(`  Created: ${filename}`);
+    }
+    console.error(`\n=== Memory Bank Initialized ===`);
+    console.error(`Documents created: ${documentsCreated.length}`);
+    return {
+        success: true,
+        message: `Memory Bank initialized for project "${projectId}" with ${documentsCreated.length} template documents. Use \`memorybank_index_code\` to index your code and \`memorybank_generate_project_docs\` to generate detailed AI documentation.`,
+        projectId,
+        docsPath,
+        documentsCreated,
+        alreadyExists: false,
+    };
+}
+/**
+ * Tool definition for MCP
+ */
+export const initializeMemoryBankToolDefinition = {
+    name: "memorybank_initialize",
+    description: `Inicializa el Memory Bank para un proyecto nuevo. Crea la estructura de directorios y 7 documentos markdown con plantillas iniciales:
+
+- projectBrief.md: Descripción general del proyecto
+- productContext.md: Contexto de producto y usuarios
+- systemPatterns.md: Patrones de arquitectura
+- techContext.md: Stack tecnológico
+- activeContext.md: Contexto de sesión actual
+- progress.md: Seguimiento de progreso
+- decisionLog.md: Log de decisiones técnicas
+
+Esta herramienta NO usa IA - crea plantillas estáticas. Para documentación detallada basada en análisis de código, usa \`memorybank_generate_project_docs\` después de indexar.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "Identificador único del proyecto (OBLIGATORIO)",
+            },
+            projectPath: {
+                type: "string",
+                description: "Ruta absoluta del proyecto",
+            },
+            projectName: {
+                type: "string",
+                description: "Nombre legible del proyecto (opcional, usa projectId si no se especifica)",
+            },
+            description: {
+                type: "string",
+                description: "Descripción inicial del proyecto (opcional)",
+            },
+        },
+        required: ["projectId", "projectPath"],
+    },
+};

package/dist/tools/recordDecision.js

@@ -0,0 +1,208 @@
+/**
+ * @fileoverview Record Decision tool for Memory Bank
+ * Records technical decisions with rationale in the decision log
+ */
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Category emojis for visual identification
+ */
+const CATEGORY_EMOJIS = {
+    architecture: "🏗️",
+    technology: "💻",
+    dependencies: "📦",
+    configuration: "🔧",
+    process: "📋",
+    security: "🔒",
+    performance: "⚡",
+    testing: "🧪",
+    documentation: "📝",
+    default: "📌",
+};
+/**
+ * Counts existing decisions in the log
+ */
+function countDecisions(content) {
+    const matches = content.match(/^### \d{4}-\d{2}-\d{2}/gm);
+    return matches ? matches.length : 0;
+}
+/**
+ * Formats a decision entry for the log
+ */
+function formatDecisionEntry(decision) {
+    const date = decision.date || new Date().toISOString().split("T")[0];
+    const category = decision.category || "default";
+    const emoji = CATEGORY_EMOJIS[category.toLowerCase()] || CATEGORY_EMOJIS.default;
+    let entry = `### ${date} - ${emoji} ${decision.title}
+
+**Decision**: ${decision.description}
+
+**Rationale**: ${decision.rationale}
+`;
+    if (decision.alternatives && decision.alternatives.length > 0) {
+        entry += `
+**Alternatives Considered**:
+${decision.alternatives.map(alt => `- ${alt}`).join("\n")}
+`;
+    }
+    if (decision.impact) {
+        entry += `
+**Impact**: ${decision.impact}
+`;
+    }
+    if (decision.category) {
+        entry += `
+**Category**: ${emoji} ${decision.category}
+`;
+    }
+    entry += "\n---\n";
+    return entry;
+}
+/**
+ * Records a technical decision in the decision log
+ */
+export async function recordDecision(params, storagePath = ".memorybank") {
+    const { projectId, decision } = params;
+    console.error(`\n=== Recording Decision ===`);
+    console.error(`Project ID: ${projectId}`);
+    console.error(`Decision: ${decision.title}`);
+    const docsPath = path.join(storagePath, "projects", projectId, "docs");
+    const decisionLogPath = path.join(docsPath, "decisionLog.md");
+    // Check if Memory Bank exists
+    if (!fs.existsSync(docsPath)) {
+        return {
+            success: false,
+            message: `Memory Bank not initialized for project "${projectId}". Run \`memorybank_initialize\` first.`,
+            projectId,
+            decisionTitle: decision.title,
+            totalDecisions: 0,
+        };
+    }
+    // Read existing decision log or create new one
+    let existingContent = "";
+    let totalDecisions = 0;
+    if (fs.existsSync(decisionLogPath)) {
+        existingContent = fs.readFileSync(decisionLogPath, "utf-8");
+        totalDecisions = countDecisions(existingContent);
+        console.error(`  Found ${totalDecisions} existing decisions`);
+    }
+    // Format the new decision entry
+    const newEntry = formatDecisionEntry(decision);
+    // Insert the new decision after the "## Recent Decisions" header
+    let newContent;
+    if (existingContent.includes("## Recent Decisions")) {
+        // Insert after the header
+        newContent = existingContent.replace("## Recent Decisions\n", `## Recent Decisions\n\n${newEntry}`);
+    }
+    else if (existingContent) {
+        // Prepend to existing content with header
+        newContent = `# Decision Log\n\n## Recent Decisions\n\n${newEntry}\n${existingContent}`;
+    }
+    else {
+        // Create new file
+        const date = new Date().toISOString().split("T")[0];
+        newContent = `# Decision Log
+
+This document tracks technical decisions made during the development of the project.
+
+## Recent Decisions
+
+${newEntry}
+
+## Pending Decisions
+_Add pending decisions that need to be made_
+
+## Decision Categories
+- 🏗️ Architecture
+- 💻 Technology
+- 📦 Dependencies
+- 🔧 Configuration
+- 📋 Process
+- 🔒 Security
+- ⚡ Performance
+- 🧪 Testing
+- 📝 Documentation
+
+---
+*Record new decisions with \`memorybank_record_decision\` to maintain decision history.*
+*Last updated: ${date}*
+`;
+    }
+    // Write to file
+    fs.writeFileSync(decisionLogPath, newContent, "utf-8");
+    totalDecisions += 1;
+    console.error(`  Decision recorded: ${decision.title}`);
+    console.error(`  Total decisions: ${totalDecisions}`);
+    console.error(`\n=== Decision Recorded ===`);
+    return {
+        success: true,
+        message: `Decision "${decision.title}" recorded for project "${projectId}". Total decisions: ${totalDecisions}.`,
+        projectId,
+        decisionTitle: decision.title,
+        totalDecisions,
+    };
+}
+/**
+ * Tool definition for MCP
+ */
+export const recordDecisionToolDefinition = {
+    name: "memorybank_record_decision",
+    description: `Registra una decisión técnica en el log de decisiones del proyecto.
+
+Cada decisión incluye:
+- Título descriptivo
+- Descripción de lo que se decidió
+- Rationale (por qué se tomó la decisión)
+- Alternativas consideradas (opcional)
+- Impacto esperado (opcional)
+- Categoría (opcional): architecture, technology, dependencies, configuration, process, security, performance, testing, documentation
+
+Útil para mantener un historial de decisiones arquitectónicas y técnicas para referencia futura.
+No usa IA - registro directo en el documento.`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "Identificador único del proyecto (OBLIGATORIO)",
+            },
+            decision: {
+                type: "object",
+                description: "Información de la decisión a registrar",
+                properties: {
+                    title: {
+                        type: "string",
+                        description: "Título corto y descriptivo de la decisión",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Descripción detallada de lo que se decidió",
+                    },
+                    rationale: {
+                        type: "string",
+                        description: "Por qué se tomó esta decisión",
+                    },
+                    alternatives: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Alternativas que se consideraron",
+                    },
+                    impact: {
+                        type: "string",
+                        description: "Impacto esperado de la decisión",
+                    },
+                    category: {
+                        type: "string",
+                        description: "Categoría: architecture, technology, dependencies, configuration, process, security, performance, testing, documentation",
+                    },
+                    date: {
+                        type: "string",
+                        description: "Fecha de la decisión (YYYY-MM-DD). Auto-genera si no se especifica",
+                    },
+                },
+                required: ["title", "description", "rationale"],
+            },
+        },
+        required: ["projectId", "decision"],
+    },
+};