@girardmedia/bootspring 2.2.0 → 2.3.0

package/core/context-loader.js

@@ -1,580 +0,0 @@
-/**
- * Bootspring Context Loader
- * Loads and indexes project context files for AI agent access
- *
- * Context Types:
- * - seed: SEED.md project configuration
- * - claude: CLAUDE.md AI context
- * - plan: Planning documents (MASTER_PLAN, PRD, etc.)
- * - business: Business documents (plans, competitive analysis)
- * - legal: Legal documents (terms, privacy)
- * - mvp: MVP source code
- * - logs: Action logs and history
- *
- * @package bootspring
- * @module core/context-loader
- */
-
-const fs = require('fs');
-const path = require('path');
-const config = require('./config');
-const utils = require('./utils');
-
-/**
- * Default context file locations
- */
-const CONTEXT_LOCATIONS = {
-  // Root level files
-  seed: 'SEED.md',
-  claude: 'CLAUDE.md',
-  todo: 'todo.md',
-  readme: 'README.md',
-  changelog: 'CHANGELOG.md',
-
-  // Planning folder
-  plan: 'planning/MASTER_PLAN.md',
-  prd: 'planning/PRD.md',
-  architecture: 'planning/ARCHITECTURE.md',
-  decisions: 'planning/DECISION_LOG.md',
-  roadmap: 'planning/ROADMAP.md',
-
-  // Business documents
-  business_plan: 'planning/BUSINESS_PLAN.md',
-  pitch_deck: 'planning/PITCH_DECK.md',
-  competitive: 'planning/COMPETITIVE_ANALYSIS.md',
-  market: 'planning/MARKET_RESEARCH.md',
-  financial: 'planning/FINANCIAL_MODEL.md',
-
-  // Legal documents
-  terms: 'legal/TERMS_OF_SERVICE.md',
-  privacy: 'legal/PRIVACY_POLICY.md',
-  legal_checklist: 'legal/LEGAL_CHECKLIST.md',
-
-  // MVP and code context
-  mvp_source: '.bootspring/mvp/source/',
-  mvp_references: '.bootspring/mvp/references/',
-
-  // Logs
-  logs: '.bootspring/logs/',
-  context_index: '.bootspring/context-index.json'
-};
-
-/**
- * Agent to context mapping
- * Each agent receives relevant context files automatically
- */
-const AGENT_CONTEXT_MAP = {
-  // Technical agents
-  'frontend-expert': ['seed', 'architecture', 'prd', 'mvp_source'],
-  'backend-expert': ['seed', 'architecture', 'prd', 'mvp_source'],
-  'database-expert': ['seed', 'architecture', 'mvp_source'],
-  'api-expert': ['seed', 'architecture', 'prd'],
-  'security-expert': ['architecture', 'legal_checklist', 'prd'],
-  'testing-expert': ['architecture', 'prd'],
-  'performance-expert': ['architecture', 'mvp_source'],
-  'devops-expert': ['architecture', 'plan'],
-  'ui-ux-expert': ['seed', 'prd', 'mvp_source'],
-  'code-review-expert': ['architecture', 'mvp_source'],
-
-  // Business agents
-  'business-strategy-expert': ['seed', 'business_plan', 'competitive', 'plan'],
-  'financial-expert': ['seed', 'business_plan', 'financial'],
-  'fundraising-expert': ['pitch_deck', 'financial', 'business_plan'],
-  'legal-expert': ['terms', 'privacy', 'legal_checklist'],
-  'marketing-expert': ['business_plan', 'competitive', 'plan'],
-  'sales-expert': ['business_plan', 'competitive', 'prd'],
-  'growth-expert': ['plan', 'competitive', 'market'],
-  'operations-expert': ['plan', 'architecture'],
-  'competitive-analysis-expert': ['competitive', 'market', 'business_plan'],
-  'market-research-expert': ['market', 'competitive', 'business_plan'],
-  'investor-relations-expert': ['pitch_deck', 'financial', 'plan'],
-
-  // Research agents
-  'research-expert': ['plan', 'architecture', 'prd'],
-  'data-modeling-expert': ['architecture', 'prd', 'mvp_source'],
-
-  // Technical specialists
-  'vercel-expert': ['architecture', 'prd', 'plan'],
-  'architecture-expert': ['architecture', 'prd', 'plan', 'mvp_source'],
-  'ai-integration-expert': ['seed', 'architecture', 'prd', 'mvp_source'],
-  'auth-expert': ['seed', 'architecture', 'prd', 'mvp_source'],
-  'email-expert': ['seed', 'prd', 'mvp_source'],
-  'monitoring-expert': ['architecture', 'plan'],
-  'payment-expert': ['seed', 'business_plan', 'prd', 'mvp_source'],
-  'railway-expert': ['architecture', 'plan'],
-
-  // Product and content
-  'content-expert': ['seed', 'prd', 'plan'],
-  'product-expert': ['seed', 'prd', 'plan', 'roadmap'],
-  'mobile-expert': ['seed', 'architecture', 'prd', 'mvp_source'],
-  'infrastructure-expert': ['architecture', 'plan'],
-
-  // Business specialists
-  'partnerships-expert': ['business_plan', 'competitive', 'plan'],
-  'private-equity-expert': ['pitch_deck', 'financial', 'business_plan']
-};
-
-/**
- * Get the bootspring directory path
- * @param {string} projectRoot - Project root path
- * @returns {string} Bootspring directory path
- */
-function getBootspringDir(projectRoot) {
-  return path.join(projectRoot, '.bootspring');
-}
-
-/**
- * Ensure bootspring directories exist
- * @param {string} projectRoot - Project root path
- */
-function ensureDirectories(projectRoot) {
-  const bootspringDir = getBootspringDir(projectRoot);
-  const dirs = [
-    bootspringDir,
-    path.join(bootspringDir, 'logs'),
-    path.join(bootspringDir, 'logs', 'agents'),
-    path.join(bootspringDir, 'logs', 'code'),
-    path.join(bootspringDir, 'logs', 'decisions'),
-    path.join(bootspringDir, 'logs', 'fixes'),
-    path.join(bootspringDir, 'logs', 'business'),
-    path.join(bootspringDir, 'logs', 'meetings'),
-    path.join(bootspringDir, 'mvp'),
-    path.join(bootspringDir, 'mvp', 'source'),
-    path.join(bootspringDir, 'mvp', 'references')
-  ];
-
-  for (const dir of dirs) {
-    utils.ensureDir(dir);
-  }
-}
-
-/**
- * Load a specific context file
- * @param {string} contextType - Type of context (seed, plan, prd, etc.)
- * @param {object} [options] - Options
- * @returns {object} Context data { exists, path, content, metadata }
- */
-function load(contextType, options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-
-  const relativePath = CONTEXT_LOCATIONS[contextType];
-  if (!relativePath) {
-    return { exists: false, error: `Unknown context type: ${contextType}` };
-  }
-
-  const fullPath = path.join(projectRoot, relativePath);
-
-  // Check if it's a directory (like mvp_source)
-  if (relativePath.endsWith('/')) {
-    return loadDirectory(fullPath, contextType);
-  }
-
-  // Load single file
-  if (!utils.fileExists(fullPath)) {
-    return {
-      exists: false,
-      type: contextType,
-      path: relativePath,
-      content: null
-    };
-  }
-
-  const content = utils.readFile(fullPath);
-  const stats = fs.statSync(fullPath);
-
-  return {
-    exists: true,
-    type: contextType,
-    path: relativePath,
-    fullPath: fullPath,
-    content: content,
-    metadata: {
-      size: stats.size,
-      modified: stats.mtime,
-      modifiedRelative: utils.formatRelativeTime(stats.mtime)
-    }
-  };
-}
-
-/**
- * Load all files from a directory
- * @param {string} dirPath - Directory path
- * @param {string} contextType - Context type
- * @returns {object} Directory context data
- */
-function loadDirectory(dirPath, contextType) {
-  if (!utils.fileExists(dirPath)) {
-    return {
-      exists: false,
-      type: contextType,
-      path: dirPath,
-      files: []
-    };
-  }
-
-  const files = [];
-
-  function walkDir(dir, relativeTo) {
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const relativePath = path.relative(relativeTo, fullPath);
-
-        // Skip hidden files and common excludes
-        if (entry.name.startsWith('.') ||
-            entry.name === 'node_modules' ||
-            entry.name === 'dist' ||
-            entry.name === 'build') {
-          continue;
-        }
-
-        if (entry.isDirectory()) {
-          walkDir(fullPath, relativeTo);
-        } else if (entry.isFile()) {
-          const stats = fs.statSync(fullPath);
-          files.push({
-            name: entry.name,
-            path: relativePath,
-            fullPath: fullPath,
-            size: stats.size,
-            modified: stats.mtime,
-            extension: path.extname(entry.name)
-          });
-        }
-      }
-    } catch (err) {
-      // Directory read error, skip
-    }
-  }
-
-  walkDir(dirPath, dirPath);
-
-  return {
-    exists: true,
-    type: contextType,
-    path: dirPath,
-    files: files,
-    fileCount: files.length
-  };
-}
-
-/**
- * Load a specific file from a directory context
- * @param {string} contextType - Context type (e.g., 'mvp_source')
- * @param {string} filePath - Relative file path within the context
- * @param {object} [options] - Options
- * @returns {object} File context data
- */
-function loadFile(contextType, filePath, options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-
-  const basePath = CONTEXT_LOCATIONS[contextType];
-  if (!basePath) {
-    return { exists: false, error: `Unknown context type: ${contextType}` };
-  }
-
-  const fullPath = path.join(projectRoot, basePath, filePath);
-
-  if (!utils.fileExists(fullPath)) {
-    return {
-      exists: false,
-      type: contextType,
-      path: filePath,
-      content: null
-    };
-  }
-
-  const content = utils.readFile(fullPath);
-  const stats = fs.statSync(fullPath);
-
-  return {
-    exists: true,
-    type: contextType,
-    path: filePath,
-    fullPath: fullPath,
-    content: content,
-    metadata: {
-      size: stats.size,
-      modified: stats.mtime,
-      extension: path.extname(fullPath)
-    }
-  };
-}
-
-/**
- * Get all context for a specific agent
- * @param {string} agentName - Agent name
- * @param {object} [options] - Options
- * @returns {object} Agent context data
- */
-function getAgentContext(agentName, options = {}) {
-  const contextTypes = AGENT_CONTEXT_MAP[agentName] || [];
-  const context = {
-    agent: agentName,
-    files: [],
-    summary: []
-  };
-
-  for (const contextType of contextTypes) {
-    const loaded = load(contextType, options);
-    if (loaded.exists) {
-      if (loaded.files) {
-        // Directory context
-        context.files.push({
-          type: contextType,
-          isDirectory: true,
-          fileCount: loaded.fileCount,
-          files: loaded.files.slice(0, 10) // Limit to first 10 files
-        });
-        context.summary.push(`${contextType}: ${loaded.fileCount} files`);
-      } else {
-        // Single file context
-        context.files.push({
-          type: contextType,
-          isDirectory: false,
-          path: loaded.path,
-          content: loaded.content,
-          metadata: loaded.metadata
-        });
-        context.summary.push(`${contextType}: ${loaded.path}`);
-      }
-    }
-  }
-
-  return context;
-}
-
-/**
- * List all available context types and their status
- * @param {object} [options] - Options
- * @returns {object[]} List of context statuses
- */
-function list(options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-  const results = [];
-
-  for (const [type, relativePath] of Object.entries(CONTEXT_LOCATIONS)) {
-    const fullPath = path.join(projectRoot, relativePath);
-    const exists = utils.fileExists(fullPath);
-
-    const result = {
-      type,
-      path: relativePath,
-      exists
-    };
-
-    if (exists) {
-      if (relativePath.endsWith('/')) {
-        // Directory
-        const dirContext = loadDirectory(fullPath, type);
-        result.isDirectory = true;
-        result.fileCount = dirContext.fileCount;
-      } else {
-        // File
-        const stats = fs.statSync(fullPath);
-        result.isDirectory = false;
-        result.size = stats.size;
-        result.modified = stats.mtime;
-        result.modifiedRelative = utils.formatRelativeTime(stats.mtime);
-      }
-    }
-
-    results.push(result);
-  }
-
-  return results;
-}
-
-/**
- * Search across all context files
- * @param {string} query - Search query
- * @param {object} [options] - Options { types, limit }
- * @returns {object[]} Search results
- */
-function search(query, options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-  const types = options.types || Object.keys(CONTEXT_LOCATIONS);
-  const limit = options.limit || 20;
-  const results = [];
-  const queryLower = query.toLowerCase();
-
-  for (const type of types) {
-    if (!CONTEXT_LOCATIONS[type]) continue;
-
-    const loaded = load(type, { config: cfg });
-    if (!loaded.exists) continue;
-
-    if (loaded.files) {
-      // Directory - search file names and contents
-      for (const file of loaded.files) {
-        // Search in filename
-        if (file.name.toLowerCase().includes(queryLower)) {
-          results.push({
-            type,
-            file: file.path,
-            matchType: 'filename',
-            preview: file.name
-          });
-        }
-
-        // Search in content for text files
-        if (['.md', '.txt', '.js', '.ts', '.json', '.yaml', '.yml'].includes(file.extension)) {
-          const content = utils.readFile(file.fullPath);
-          if (content && content.toLowerCase().includes(queryLower)) {
-            const lines = content.split('\n');
-            const matchingLines = lines
-              .map((line, i) => ({ line, num: i + 1 }))
-              .filter(l => l.line.toLowerCase().includes(queryLower))
-              .slice(0, 3);
-
-            results.push({
-              type,
-              file: file.path,
-              matchType: 'content',
-              matches: matchingLines.map(m => ({
-                line: m.num,
-                preview: utils.truncate(m.line.trim(), 100)
-              }))
-            });
-          }
-        }
-
-        if (results.length >= limit) break;
-      }
-    } else if (loaded.content) {
-      // Single file - search content
-      const content = loaded.content;
-      if (content.toLowerCase().includes(queryLower)) {
-        const lines = content.split('\n');
-        const matchingLines = lines
-          .map((line, i) => ({ line, num: i + 1 }))
-          .filter(l => l.line.toLowerCase().includes(queryLower))
-          .slice(0, 5);
-
-        results.push({
-          type,
-          file: loaded.path,
-          matchType: 'content',
-          matches: matchingLines.map(m => ({
-            line: m.num,
-            preview: utils.truncate(m.line.trim(), 100)
-          }))
-        });
-      }
-    }
-
-    if (results.length >= limit) break;
-  }
-
-  return results.slice(0, limit);
-}
-
-/**
- * Build or update the context index
- * @param {object} [options] - Options
- * @returns {object} Index data
- */
-function buildIndex(options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-
-  ensureDirectories(projectRoot);
-
-  const index = {
-    version: '1.0',
-    lastUpdated: new Date().toISOString(),
-    projectRoot: projectRoot,
-    files: [],
-    agents: {}
-  };
-
-  // Index all context files
-  const contextList = list({ config: cfg });
-  for (const ctx of contextList) {
-    if (ctx.exists) {
-      index.files.push({
-        type: ctx.type,
-        path: ctx.path,
-        isDirectory: ctx.isDirectory,
-        fileCount: ctx.fileCount,
-        size: ctx.size,
-        modified: ctx.modified
-      });
-    }
-  }
-
-  // Build agent context mappings
-  for (const [agent, types] of Object.entries(AGENT_CONTEXT_MAP)) {
-    const availableTypes = types.filter(t => {
-      const ctx = contextList.find(c => c.type === t);
-      return ctx && ctx.exists;
-    });
-    index.agents[agent] = availableTypes;
-  }
-
-  // Save index
-  const indexPath = path.join(projectRoot, CONTEXT_LOCATIONS.context_index);
-  utils.writeFile(indexPath, JSON.stringify(index, null, 2));
-
-  return index;
-}
-
-/**
- * Load the context index
- * @param {object} [options] - Options
- * @returns {object|null} Index data or null
- */
-function loadIndex(options = {}) {
-  const cfg = options.config || config.load();
-  const projectRoot = cfg._projectRoot;
-  const indexPath = path.join(projectRoot, CONTEXT_LOCATIONS.context_index);
-
-  if (!utils.fileExists(indexPath)) {
-    return null;
-  }
-
-  try {
-    const content = utils.readFile(indexPath);
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get context locations configuration
- * @returns {object} Context locations
- */
-function getLocations() {
-  return { ...CONTEXT_LOCATIONS };
-}
-
-/**
- * Get agent context mapping
- * @returns {object} Agent context map
- */
-function getAgentMap() {
-  return { ...AGENT_CONTEXT_MAP };
-}
-
-module.exports = {
-  load,
-  loadFile,
-  loadDirectory,
-  getAgentContext,
-  list,
-  search,
-  buildIndex,
-  loadIndex,
-  ensureDirectories,
-  getLocations,
-  getAgentMap,
-  CONTEXT_LOCATIONS,
-  AGENT_CONTEXT_MAP
-};

package/core/context.d.ts

@@ -1,61 +0,0 @@
-/**
- * Bootspring Context Types
- * @module core/context
- */
-
-export interface ProjectContext {
-  project: {
-    name: string;
-    description: string;
-    version: string;
-  };
-  stack: {
-    framework: string;
-    language: string;
-    database: string;
-    hosting: string;
-  };
-  paths: {
-    root: string;
-    config: string;
-    context: string;
-  };
-  plugins: Record<string, { enabled: boolean; provider?: string }>;
-  agents: string[];
-  skills: string[];
-}
-
-export interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-  warnings: string[];
-}
-
-/**
- * Get project context
- * @param projectRoot - Optional project root path
- * @returns Project context object
- */
-export function get(projectRoot?: string): ProjectContext;
-
-/**
- * Validate project context
- * @param context - Context to validate
- * @returns Validation result
- */
-export function validate(context: unknown): ValidationResult;
-
-/**
- * Load context from CLAUDE.md file
- * @param filePath - Path to CLAUDE.md
- * @returns Parsed context or null
- */
-export function load(filePath: string): ProjectContext | null;
-
-/**
- * Save context to CLAUDE.md file
- * @param context - Context to save
- * @param filePath - Path to save to
- * @returns True if saved successfully
- */
-export function save(context: ProjectContext, filePath: string): boolean;