@girardmedia/bootspring 1.1.0

package/mcp/tools/skill-tool.js

@@ -0,0 +1,233 @@
+/**
+ * MCP skill tool module
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_skill',
+    description: 'Search and retrieve code patterns/skills. Find battle-tested implementations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'show', 'search', 'sync'],
+          description: 'Action: list all skills, show a skill, search, or sync remote external catalog'
+        },
+        name: {
+          type: 'string',
+          description: 'Skill name (e.g., auth/clerk, database/prisma)'
+        },
+        query: {
+          type: 'string',
+          description: 'Search query'
+        },
+        includeExternal: {
+          type: 'boolean',
+          description: 'Include external skills from skills/external'
+        },
+        limit: {
+          type: 'number',
+          description: 'Limit list/search result count (default: 50)'
+        },
+        summary: {
+          type: 'boolean',
+          description: 'For action=show, return concise summary instead of full content'
+        },
+        sections: {
+          type: 'string',
+          description: 'For action=show, comma-separated section keywords to include'
+        },
+        maxChars: {
+          type: 'number',
+          description: 'For action=show, cap returned content length'
+        },
+        mode: {
+          type: 'string',
+          enum: ['local', 'server'],
+          description: 'Optional entitlement mode override (default: local)'
+        },
+        entitled: {
+          type: 'boolean',
+          description: 'Optional entitlement override for external skills'
+        },
+        tier: {
+          type: 'string',
+          description: 'Optional tier override (free, pro, team, enterprise)'
+        },
+        manifestUrl: {
+          type: 'string',
+          description: 'For action=sync, remote manifest URL'
+        },
+        contentBaseUrl: {
+          type: 'string',
+          description: 'For action=sync, fallback base URL for SKILL.md files'
+        },
+        token: {
+          type: 'string',
+          description: 'For action=sync, optional bearer token'
+        },
+        cacheDir: {
+          type: 'string',
+          description: 'For action=sync, local cache directory override'
+        },
+        manifestPublicKey: {
+          type: 'string',
+          description: 'For action=sync, PEM public key for manifest signature verification'
+        },
+        requireManifestSignature: {
+          type: 'boolean',
+          description: 'For action=sync, require signature validation'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ skills, entitlements, trackTelemetry }) {
+  return async (args) => {
+    const {
+      action,
+      name,
+      query,
+      includeExternal = false,
+      summary = false,
+      sections,
+      maxChars,
+      mode,
+      entitled,
+      tier,
+      manifestUrl,
+      contentBaseUrl,
+      token,
+      cacheDir,
+      manifestPublicKey,
+      requireManifestSignature
+    } = args;
+
+    const parsedLimit = Number(args.limit);
+    const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 50;
+    const accessOptions = { mode, entitled, tier };
+
+    switch (action) {
+      case 'list': {
+        let skillIds = skills.listSkills({ includeExternal });
+        if (includeExternal) {
+          skillIds = entitlements.filterAccessibleSkills(skillIds, accessOptions).allowed;
+        }
+        const items = skillIds
+          .slice(0, limit)
+          .map(id => {
+            const metadata = skills.getSkillMetadata(id) || {};
+            return {
+              id,
+              name: metadata.name || id,
+              description: metadata.description || ''
+            };
+          });
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(items, null, 2)
+          }]
+        };
+      }
+      case 'show': {
+        if (!name) throw new Error('Skill name required');
+        const metadata = skills.getSkillMetadata(name);
+        const targetSkillId = metadata?.id || name;
+        const access = entitlements.checkSkillAccess(targetSkillId, accessOptions);
+        if (!access.allowed) {
+          trackTelemetry('premium_prompted', {
+            capability: 'external_skill',
+            skillId: targetSkillId,
+            mode: access.context?.mode,
+            tier: access.context?.tier,
+            reason: access.code
+          });
+          throw new Error(access.reason);
+        }
+        const rawContent = skills.loadSkill(name, {
+          includeExternal: includeExternal || entitlements.isExternalSkill(targetSkillId)
+        });
+        if (!rawContent) throw new Error(`Skill not found: ${name}`);
+        const content = skills.formatSkillContent(rawContent, {
+          summary,
+          sections,
+          maxChars
+        });
+        if (entitlements.isExternalSkill(targetSkillId)) {
+          trackTelemetry('premium_unlocked', {
+            capability: 'external_skill',
+            skillId: targetSkillId,
+            mode: access.context?.mode,
+            tier: access.context?.tier,
+            reason: access.code
+          });
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              id: metadata?.id || name,
+              name: metadata?.name || name,
+              description: metadata?.description || '',
+              source: metadata?.source || 'built-in',
+              content
+            }, null, 2)
+          }]
+        };
+      }
+      case 'search': {
+        if (!query) throw new Error('Search query required');
+        let matches = skills.searchSkills(query, { includeExternal, limit });
+        if (includeExternal) {
+          matches = entitlements.filterAccessibleSkills(matches, accessOptions).allowed;
+        }
+        const items = matches
+          .map(id => {
+            const metadata = skills.getSkillMetadata(id) || {};
+            return {
+              id,
+              name: metadata.name || id,
+              description: metadata.description || '',
+              source: metadata.source || 'built-in'
+            };
+          });
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(items, null, 2)
+          }]
+        };
+      }
+      case 'sync': {
+        const result = await skills.syncExternalCatalog({
+          manifestUrl,
+          contentBaseUrl,
+          token,
+          cacheDir,
+          manifestPublicKey,
+          requireManifestSignature
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/telemetry-tool.js

@@ -0,0 +1,95 @@
+/**
+ * MCP telemetry tool module
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_telemetry',
+    description: 'Inspect and upload Bootspring telemetry events.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['status', 'list', 'upload', 'clear'],
+          description: 'Action: status, list, upload, or clear'
+        },
+        event: {
+          type: 'string',
+          description: 'Optional event filter'
+        },
+        limit: {
+          type: 'number',
+          description: 'Optional event limit for list/upload'
+        },
+        endpoint: {
+          type: 'string',
+          description: 'Optional upload endpoint override'
+        },
+        token: {
+          type: 'string',
+          description: 'Optional upload bearer token override'
+        },
+        clearOnSuccess: {
+          type: 'boolean',
+          description: 'For action=upload, clear local events on success'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ telemetry }) {
+  return async (args) => {
+    const { action, event, endpoint, token, clearOnSuccess } = args;
+    const limit = Number(args.limit);
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? limit : undefined;
+
+    switch (action) {
+      case 'status':
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(telemetry.getStatus(), null, 2)
+          }]
+        };
+      case 'list':
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(telemetry.listEvents({ event, limit: safeLimit }), null, 2)
+          }]
+        };
+      case 'upload': {
+        const result = await telemetry.uploadEvents({
+          event,
+          limit: safeLimit,
+          endpoint,
+          token,
+          clearOnSuccess: Boolean(clearOnSuccess)
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+      case 'clear':
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(telemetry.clearEvents(), null, 2)
+          }]
+        };
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/todo-tool.js

@@ -0,0 +1,133 @@
+/**
+ * MCP todo tool module
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_todo',
+    description: 'Manage project todo items. Add, list, complete, or remove tasks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'add', 'done', 'remove', 'clear'],
+          description: 'Action: list, add, done (complete), remove, or clear'
+        },
+        text: {
+          type: 'string',
+          description: 'Todo text (when adding)'
+        },
+        index: {
+          type: 'number',
+          description: 'Todo index number (when completing or removing)'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ config, todoModule, format }) {
+  return async (args) => {
+    const { action, text, index } = args;
+    const cfg = config.load();
+    const todoPath = path.join(cfg._projectRoot, cfg.paths?.todo || 'todo.md');
+
+    let content = '';
+    if (fs.existsSync(todoPath)) {
+      content = fs.readFileSync(todoPath, 'utf-8');
+    } else {
+      content = '# Todo List\n\n## Pending\n\n## Completed\n';
+      fs.writeFileSync(todoPath, content);
+    }
+
+    const todos = todoModule.parseTodos(content);
+
+    switch (action) {
+      case 'list': {
+        const pending = todos.filter(t => !t.completed);
+        const completed = todos.filter(t => t.completed);
+        return format.todoList(pending, completed);
+      }
+      case 'add': {
+        if (!text) return format.error('Todo text required', ['Provide text="your task"']);
+        const lines = content.split('\n');
+
+        let insertIndex = lines.length;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].match(/^##?\s*(Pending|In Progress|Todo)/i)) {
+            insertIndex = i + 1;
+            while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+              insertIndex++;
+            }
+            break;
+          }
+        }
+
+        lines.splice(insertIndex, 0, `- [ ] ${text}`);
+        fs.writeFileSync(todoPath, lines.join('\n'));
+
+        return format.success({
+          summary: `Added todo: "${text}"`,
+          hints: ['Use action=list to see all todos']
+        });
+      }
+      case 'done': {
+        if (index === undefined) return format.error('Todo index required', ['Provide index=0']);
+        const todo = todos.find(t => t.index === index);
+        if (!todo) return format.error(`Todo #${index} not found`, ['Use action=list to see valid indices']);
+
+        const lines = content.split('\n');
+        lines[todo.line] = lines[todo.line].replace('[ ]', '[x]');
+        fs.writeFileSync(todoPath, lines.join('\n'));
+
+        return format.success({
+          summary: `Completed: "${todo.text}" 🎉`,
+          hints: ['Use action=list to see remaining todos']
+        });
+      }
+      case 'remove': {
+        if (index === undefined) return format.error('Todo index required', ['Provide index=0']);
+        const todo = todos.find(t => t.index === index);
+        if (!todo) return format.error(`Todo #${index} not found`, ['Use action=list to see valid indices']);
+
+        const lines = content.split('\n');
+        lines.splice(todo.line, 1);
+        fs.writeFileSync(todoPath, lines.join('\n'));
+
+        return format.success({
+          summary: `Removed: "${todo.text}"`,
+          hints: ['Use action=list to see remaining todos']
+        });
+      }
+      case 'clear': {
+        const completed = todos.filter(t => t.completed);
+        const lines = content.split('\n');
+        const linesToRemove = completed.map(t => t.line).sort((a, b) => b - a);
+
+        for (const lineIndex of linesToRemove) {
+          lines.splice(lineIndex, 1);
+        }
+        fs.writeFileSync(todoPath, lines.join('\n'));
+
+        return format.success({
+          summary: `Cleared ${completed.length} completed todos`,
+          hints: completed.length > 0 ? ['Todo list is now clean!'] : ['No completed todos to clear']
+        });
+      }
+      default:
+        return format.error(`Unknown action: ${action}`, [
+          'Valid actions: list, add, done, remove, clear'
+        ]);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@girardmedia/bootspring",
+  "version": "1.1.0",
+  "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
+  "keywords": [
+    "ai",
+    "development",
+    "scaffolding",
+    "mcp",
+    "claude",
+    "agents",
+    "context",
+    "workflow",
+    "devtools"
+  ],
+  "author": "Bootspring",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bootspring/bootspring.git"
+  },
+  "homepage": "https://bootspring.com",
+  "bugs": {
+    "url": "https://github.com/bootspring/bootspring/issues"
+  },
+  "bin": {
+    "bootspring": "./bin/bootspring.js"
+  },
+  "main": "./core/index.js",
+  "exports": {
+    ".": "./core/index.js",
+    "./mcp": "./mcp/server.js",
+    "./hooks": "./hooks/index.js",
+    "./agents": "./agents/index.js",
+    "./skills": "./skills/index.js",
+    "./plugins": "./plugins/index.js",
+    "./intelligence": "./intelligence/index.js",
+    "./generators": "./generators/index.js",
+    "./quality": "./quality/index.js"
+  },
+  "files": [
+    "bin/",
+    "core/",
+    "cli/",
+    "mcp/",
+    "hooks/",
+    "agents/",
+    "skills/index.js",
+    "skills/patterns/",
+    "plugins/",
+    "dashboard/",
+    "quality/",
+    "templates/",
+    "docs/",
+    "intelligence/",
+    "generators/"
+  ],
+  "scripts": {
+    "start": "node bin/bootspring.js",
+    "dashboard": "node bin/bootspring.js dashboard",
+    "mcp": "node mcp/server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "verify:lint-budget": "node scripts/check-lint-budgets.js",
+    "build:mcp-contract": "node scripts/export-mcp-contract.js",
+    "verify:mcp-contract": "node scripts/export-mcp-contract.js --check",
+    "verify:package": "node scripts/check-package-boundaries.js",
+    "prepublishOnly": "npm test && npm run lint --if-present && npm run verify:package && npm run verify:mcp-contract"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "jest": "^29.7.0"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "yaml": "^2.8.0"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.25.0"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/plugins/index.js

@@ -0,0 +1,141 @@
+/**
+ * Bootspring Plugins Module
+ * Plugin management and configuration
+ */
+
+// Available plugins and their providers
+const PLUGINS = {
+  auth: {
+    name: 'Authentication',
+    description: 'User authentication and session management',
+    providers: ['clerk', 'nextauth', 'auth0', 'supabase'],
+    defaultProvider: 'clerk',
+    features: ['social_login', 'email_password', 'organizations', 'mfa']
+  },
+  payments: {
+    name: 'Payments',
+    description: 'Payment processing and subscriptions',
+    providers: ['stripe', 'paddle', 'lemonsqueezy'],
+    defaultProvider: 'stripe',
+    features: ['checkout', 'subscriptions', 'webhooks', 'customer_portal']
+  },
+  database: {
+    name: 'Database',
+    description: 'Database ORM and management',
+    providers: ['prisma', 'drizzle', 'typeorm', 'mongoose'],
+    defaultProvider: 'prisma',
+    features: ['migrations', 'transactions', 'soft_deletes', 'seeding']
+  },
+  testing: {
+    name: 'Testing',
+    description: 'Testing framework and utilities',
+    providers: ['vitest', 'jest', 'playwright'],
+    defaultProvider: 'vitest',
+    features: ['unit', 'integration', 'e2e', 'coverage']
+  },
+  security: {
+    name: 'Security',
+    description: 'Security features and validation',
+    providers: ['default'],
+    defaultProvider: 'default',
+    features: ['input_validation', 'rate_limiting', 'csrf', 'headers']
+  },
+  ai: {
+    name: 'AI',
+    description: 'AI/LLM integration',
+    providers: ['anthropic', 'openai', 'google'],
+    defaultProvider: 'anthropic',
+    features: ['streaming', 'tool_use', 'structured_output', 'embeddings']
+  }
+};
+
+/**
+ * Get all available plugins
+ */
+function getPlugins() {
+  return PLUGINS;
+}
+
+/**
+ * Get a specific plugin
+ */
+function getPlugin(name) {
+  return PLUGINS[name] || null;
+}
+
+/**
+ * List plugin names
+ */
+function listPlugins() {
+  return Object.keys(PLUGINS);
+}
+
+/**
+ * Get providers for a plugin
+ */
+function getProviders(pluginName) {
+  const plugin = PLUGINS[pluginName];
+  return plugin ? plugin.providers : [];
+}
+
+/**
+ * Check if a provider is valid for a plugin
+ */
+function isValidProvider(pluginName, providerName) {
+  const providers = getProviders(pluginName);
+  return providers.includes(providerName);
+}
+
+/**
+ * Get plugin configuration template
+ */
+function getPluginConfig(pluginName, provider = null) {
+  const plugin = PLUGINS[pluginName];
+  if (!plugin) return null;
+
+  return {
+    enabled: true,
+    provider: provider || plugin.defaultProvider,
+    features: plugin.features
+  };
+}
+
+/**
+ * Validate plugin configuration
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  if (!config || typeof config !== 'object') {
+    return { valid: false, errors: ['Configuration must be an object'] };
+  }
+
+  for (const [pluginName, pluginConfig] of Object.entries(config)) {
+    if (!PLUGINS[pluginName]) {
+      errors.push(`Unknown plugin: ${pluginName}`);
+      continue;
+    }
+
+    if (pluginConfig.enabled && pluginConfig.provider) {
+      if (!isValidProvider(pluginName, pluginConfig.provider)) {
+        errors.push(`Invalid provider '${pluginConfig.provider}' for plugin '${pluginName}'`);
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+module.exports = {
+  PLUGINS,
+  getPlugins,
+  getPlugin,
+  listPlugins,
+  getProviders,
+  isValidProvider,
+  getPluginConfig,
+  validateConfig
+};