@iservu-inc/adf-cli 0.10.0 → 0.12.0

package/lib/utils/context-manager.js

@@ -0,0 +1,484 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Context Manager
+ * Manages the .context/ directory structure for Agent-Native Development Framework (ANDF)
+ *
+ * The .context/ directory contains agent-accessible deep context:
+ * - /memory/architecture.md - System architecture and design decisions
+ * - /memory/glossary.md - Domain-specific terminology
+ * - /skills/ - Executable scripts and tools
+ */
+class ContextManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.contextPath = path.join(projectPath, '.context');
+    this.memoryPath = path.join(this.contextPath, 'memory');
+    this.skillsPath = path.join(this.contextPath, 'skills');
+  }
+
+  /**
+   * Create complete .context/ directory structure
+   * @returns {Promise<object>} Created paths
+   */
+  async createStructure() {
+    const created = {
+      context: this.contextPath,
+      memory: this.memoryPath,
+      skills: this.skillsPath
+    };
+
+    // Create directories
+    await fs.ensureDir(this.memoryPath);
+    await fs.ensureDir(this.skillsPath);
+
+    // Create README to explain the structure
+    const readmePath = path.join(this.contextPath, 'README.md');
+    if (!await fs.pathExists(readmePath)) {
+      await this.createContextReadme(readmePath);
+    }
+
+    return created;
+  }
+
+  /**
+   * Create README.md explaining the .context/ directory
+   */
+  async createContextReadme(readmePath) {
+    const readmeContent = `# .context Directory
+
+This directory contains agent-accessible deep context for AI coding assistants.
+
+## Structure
+
+- \`/memory/\` - Deep memory and knowledge base
+  - \`architecture.md\` - System architecture and design decisions
+  - \`glossary.md\` - Domain-specific terminology and definitions
+
+- \`/skills/\` - Executable scripts and tools
+  - Helper scripts that agents can reference or execute
+
+## Purpose
+
+The \`.context/\` directory follows the Agent-Native Development Framework (ANDF) specification.
+AI coding assistants reference these files via the Model Context Protocol (MCP) to:
+- Understand system architecture before making changes
+- Learn domain-specific terminology
+- Access helper scripts and tools
+
+## DO NOT MODIFY
+
+This directory is managed by ADF CLI. Contents are generated from interview sessions.
+Manual changes may be overwritten during deployment.
+
+For more information, see: AGENTS.md
+`;
+
+    await fs.writeFile(readmePath, readmeContent, 'utf-8');
+  }
+
+  /**
+   * Generate architecture.md from session outputs
+   * @param {string} sessionPath - Path to ADF session
+   * @param {string} framework - Framework type (rapid/balanced/comprehensive)
+   */
+  async generateArchitecture(sessionPath, framework) {
+    const archPath = path.join(this.memoryPath, 'architecture.md');
+
+    let content;
+    if (framework === 'rapid') {
+      content = await this.generateArchitectureFromPRP(sessionPath);
+    } else if (framework === 'balanced') {
+      content = await this.generateArchitectureFromBalanced(sessionPath);
+    } else if (framework === 'comprehensive') {
+      content = await this.generateArchitectureFromBMAD(sessionPath);
+    } else {
+      throw new Error(`Unknown framework: ${framework}`);
+    }
+
+    await fs.writeFile(archPath, content, 'utf-8');
+    return archPath;
+  }
+
+  /**
+   * Generate architecture.md from PRP (Rapid) outputs
+   */
+  async generateArchitectureFromPRP(sessionPath) {
+    const prpPath = path.join(sessionPath, 'outputs', 'prp.md');
+
+    if (!await fs.pathExists(prpPath)) {
+      return this.getDefaultArchitecture();
+    }
+
+    const prpContent = await fs.readFile(prpPath, 'utf-8');
+
+    // Extract sections from PRP
+    const goalDef = this.extractPRPSection(prpContent, '1. Goal Definition');
+    const contextIntel = this.extractPRPSection(prpContent, '3. Contextual Intelligence');
+    const blueprint = this.extractPRPSection(prpContent, '4. Implementation Blueprint');
+
+    return `# System Architecture
+
+**Framework:** Rapid Development (PRP)
+**Generated:** ${new Date().toISOString()}
+
+## Overview
+
+${goalDef || 'See PRP document for project overview'}
+
+## Technical Context
+
+${contextIntel || 'See PRP document for technical context'}
+
+## Implementation Architecture
+
+${blueprint || 'See PRP document for implementation blueprint'}
+
+## Design Decisions
+
+### Architecture Pattern
+- Pattern to be determined during implementation
+- Follow modern best practices for the chosen tech stack
+
+### Tech Stack
+See "3. Contextual Intelligence" section in PRP document for complete tech stack.
+
+## Key Components
+
+To be defined during implementation based on the blueprint above.
+
+## Data Flow
+
+To be defined during implementation.
+
+## Security Considerations
+
+- Follow OWASP security best practices
+- Validate all user input
+- Use environment variables for sensitive configuration
+- Implement proper authentication and authorization
+
+## Performance Considerations
+
+- Optimize critical rendering paths
+- Minimize database queries
+- Cache where appropriate
+- Monitor resource usage
+
+---
+
+*For complete requirements, see: \`.adf/sessions/[session]/outputs/prp.md\`*
+`;
+  }
+
+  /**
+   * Generate architecture.md from Balanced outputs
+   */
+  async generateArchitectureFromBalanced(sessionPath) {
+    const specPath = path.join(sessionPath, 'outputs', 'specification.md');
+    const planPath = path.join(sessionPath, 'outputs', 'plan.md');
+    const constitutionPath = path.join(sessionPath, 'outputs', 'constitution.md');
+
+    const spec = await fs.pathExists(specPath) ? await fs.readFile(specPath, 'utf-8') : '';
+    const plan = await fs.pathExists(planPath) ? await fs.readFile(planPath, 'utf-8') : '';
+    const constitution = await fs.pathExists(constitutionPath) ? await fs.readFile(constitutionPath, 'utf-8') : '';
+
+    const archSection = this.extractSection(spec, 'Architecture');
+    const techStack = this.extractSection(plan, 'Technology Stack');
+    const principles = this.extractSection(constitution, 'Core Principles');
+    const constraints = this.extractSection(constitution, 'Constraints');
+
+    return `# System Architecture
+
+**Framework:** Balanced (Specification-Driven)
+**Generated:** ${new Date().toISOString()}
+
+## Core Principles
+
+${principles || 'See constitution.md for core principles'}
+
+## System Constraints
+
+${constraints || 'See constitution.md for constraints'}
+
+## Architecture Overview
+
+${archSection || 'See specification.md for complete architecture'}
+
+## Technology Stack
+
+${techStack || 'See plan.md for technology stack'}
+
+## Component Design
+
+See specification.md for detailed component design and interactions.
+
+## Data Architecture
+
+See specification.md for data models, database schema, and data flow.
+
+## API Design
+
+See specification.md for API endpoints, request/response formats, and integration points.
+
+## Security Architecture
+
+- Follow security principles defined in constitution.md
+- Implement authentication and authorization per specification
+- Validate all inputs, sanitize all outputs
+- Use HTTPS for all communications
+- See specification.md for security requirements
+
+## Performance Architecture
+
+- Follow performance constraints in constitution.md
+- Optimize based on requirements in specification.md
+- Monitor critical paths and resource usage
+
+## Deployment Architecture
+
+See plan.md for deployment strategy and infrastructure requirements.
+
+---
+
+*For complete details, see:*
+- *Constitution: \`.adf/sessions/[session]/outputs/constitution.md\`*
+- *Specification: \`.adf/sessions/[session]/outputs/specification.md\`*
+- *Technical Plan: \`.adf/sessions/[session]/outputs/plan.md\`*
+`;
+  }
+
+  /**
+   * Generate architecture.md from BMAD (Comprehensive) outputs
+   */
+  async generateArchitectureFromBMAD(sessionPath) {
+    const archPath = path.join(sessionPath, 'outputs', 'architecture.md');
+    const prdPath = path.join(sessionPath, 'outputs', 'prd.md');
+
+    if (await fs.pathExists(archPath)) {
+      // BMAD already has architecture.md, so copy it
+      const archContent = await fs.readFile(archPath, 'utf-8');
+      return `${archContent}\n\n---\n\n*Copied from: \`.adf/sessions/[session]/outputs/architecture.md\`*\n*Generated: ${new Date().toISOString()}*`;
+    }
+
+    // Fallback: extract from PRD
+    const prd = await fs.pathExists(prdPath) ? await fs.readFile(prdPath, 'utf-8') : '';
+    const techReq = this.extractSection(prd, 'Technical Requirements');
+    const archReq = this.extractSection(prd, 'Technical Architecture');
+
+    return `# System Architecture
+
+**Framework:** BMAD Comprehensive (Enterprise)
+**Generated:** ${new Date().toISOString()}
+
+## Enterprise Architecture Overview
+
+${archReq || techReq || 'See architecture.md and prd.md for complete enterprise architecture'}
+
+## System Components
+
+See architecture.md for detailed component breakdown and responsibilities.
+
+## Integration Architecture
+
+See architecture.md for integration patterns, APIs, and external system connections.
+
+## Data Architecture
+
+See architecture.md for:
+- Data models and schemas
+- Database architecture
+- Data flow and transformations
+- Caching strategy
+
+## Security Architecture
+
+See architecture.md and prd.md for:
+- Authentication and authorization patterns
+- Security layers and controls
+- Compliance requirements
+- Threat model and mitigations
+
+## Performance & Scalability
+
+See architecture.md for:
+- Performance targets and benchmarks
+- Scalability patterns
+- Load balancing and distribution
+- Resource optimization
+
+## Deployment Architecture
+
+See architecture.md for:
+- Infrastructure design
+- Deployment pipelines
+- Environment strategy
+- Disaster recovery
+
+---
+
+*For complete enterprise architecture, see:*
+- *Architecture Document: \`.adf/sessions/[session]/outputs/architecture.md\`*
+- *PRD: \`.adf/sessions/[session]/outputs/prd.md\`*
+- *User Stories: \`.adf/sessions/[session]/outputs/stories.md\`*
+`;
+  }
+
+  /**
+   * Generate glossary.md from session outputs
+   * @param {string} sessionPath - Path to ADF session
+   * @param {string} framework - Framework type
+   */
+  async generateGlossary(sessionPath, framework) {
+    const glossaryPath = path.join(this.memoryPath, 'glossary.md');
+
+    // Extract domain terms from interview transcripts
+    const transcriptPath = path.join(sessionPath, '_transcript.json');
+    let terms = {};
+
+    if (await fs.pathExists(transcriptPath)) {
+      const transcript = await fs.readJson(transcriptPath);
+      terms = this.extractTermsFromTranscript(transcript);
+    }
+
+    const content = this.generateGlossaryContent(terms, framework);
+    await fs.writeFile(glossaryPath, content, 'utf-8');
+
+    return glossaryPath;
+  }
+
+  /**
+   * Extract domain terms from interview transcript
+   */
+  extractTermsFromTranscript(transcript) {
+    const terms = {};
+
+    // Look for capitalized terms, technical acronyms, and domain-specific language
+    const entries = Array.isArray(transcript) ? transcript : [];
+
+    for (const entry of entries) {
+      if (entry.answer && typeof entry.answer === 'string') {
+        // Extract potential domain terms (capitalized words, acronyms)
+        const matches = entry.answer.match(/\b[A-Z][A-Z0-9]{2,}\b|\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/g);
+        if (matches) {
+          for (const term of matches) {
+            if (!terms[term] && term.length > 2) {
+              terms[term] = this.extractTermDefinition(entry.answer, term);
+            }
+          }
+        }
+      }
+    }
+
+    return terms;
+  }
+
+  /**
+   * Extract definition for a term from context
+   */
+  extractTermDefinition(text, term) {
+    // Try to find a sentence that defines or explains the term
+    const sentences = text.split(/[.!?]+/);
+    for (const sentence of sentences) {
+      if (sentence.includes(term)) {
+        return sentence.trim();
+      }
+    }
+    return 'Domain-specific term used in this project';
+  }
+
+  /**
+   * Generate glossary content
+   */
+  generateGlossaryContent(terms, framework) {
+    const termEntries = Object.entries(terms)
+      .filter(([term]) => term.length > 2)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([term, definition]) => `### ${term}\n\n${definition}\n`)
+      .join('\n');
+
+    return `# Project Glossary
+
+**Framework:** ${this.getFrameworkName(framework)}
+**Generated:** ${new Date().toISOString()}
+
+This glossary defines domain-specific terms and technical concepts used throughout this project.
+
+## Terms
+
+${termEntries || '### (No terms extracted)\n\nDomain terminology will be added as the project evolves.'}
+
+## Adding Terms
+
+To add new terms to this glossary:
+1. Terms are automatically extracted from interview responses
+2. Manual additions can be made to this file
+3. Follow the format: \`### Term Name\\n\\nDefinition or explanation.\\n\`
+
+---
+
+*Auto-generated from interview transcript. Manual edits will be preserved during re-generation.*
+`;
+  }
+
+  /**
+   * Extract section from PRP content
+   */
+  extractPRPSection(content, sectionName) {
+    const regex = new RegExp(`##\\s*${sectionName}([\\s\\S]*?)(?=##|$)`, 'i');
+    const match = content.match(regex);
+    return match ? match[1].trim() : '';
+  }
+
+  /**
+   * Extract section from markdown content
+   */
+  extractSection(content, sectionName) {
+    if (!content) return '';
+
+    const regex = new RegExp(`##\\s*${sectionName}([\\s\\S]*?)(?=##|$)`, 'i');
+    const match = content.match(regex);
+    return match ? match[1].trim() : '';
+  }
+
+  /**
+   * Get default architecture content
+   */
+  getDefaultArchitecture() {
+    return `# System Architecture
+
+**Generated:** ${new Date().toISOString()}
+
+## Overview
+
+System architecture to be defined based on project requirements.
+
+## Components
+
+To be defined during implementation.
+
+## Design Decisions
+
+To be documented as architectural decisions are made.
+
+---
+
+*This is a placeholder. Complete architecture details will be added as the project evolves.*
+`;
+  }
+
+  /**
+   * Get framework display name
+   */
+  getFrameworkName(framework) {
+    const names = {
+      'rapid': 'Rapid Development (PRP)',
+      'balanced': 'Balanced (Specification-Driven)',
+      'comprehensive': 'BMAD Comprehensive (Enterprise)'
+    };
+    return names[framework] || framework;
+  }
+}
+
+module.exports = ContextManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {
@@ -27,6 +27,11 @@
     "windsurf",
     "cursor",
     "claude-code",
+    "zed",
+    "antigravity",
+    "andf",
+    "agents-md",
+    "mcp",
     "anthropic",
     "openai",
     "gemini",