@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/scripts/lib/client-manager.js

@@ -0,0 +1,300 @@
+/**
+ * Client Manager - Client Discovery and Context Loading
+ *
+ * Provides utilities for:
+ * - Discovering client directories in clients/
+ * - Loading client configuration from CLAUDE.md
+ * - Parsing .env.client files
+ * - Fetching client-specific git activity
+ *
+ * @module client-manager
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { runCommand, readFile, log } = require('./utils');
+
+/**
+ * Get the clients directory path
+ * Clients are stored in clients/ at the repo root
+ */
+function getClientsDir() {
+  // Look for clients/ relative to the repo root
+  // Start from current working directory and search upward
+  let currentDir = process.cwd();
+  const maxDepth = 10;
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    const clientsPath = path.join(currentDir, 'clients');
+    if (fs.existsSync(clientsPath) && fs.statSync(clientsPath).isDirectory()) {
+      return clientsPath;
+    }
+
+    // Also check if we're in a Claude Code plugin directory
+    const pluginClientsPath = path.join(currentDir, '..', 'clients');
+    if (fs.existsSync(pluginClientsPath) && fs.statSync(pluginClientsPath).isDirectory()) {
+      return pluginClientsPath;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break; // Reached root
+    currentDir = parentDir;
+    depth++;
+  }
+
+  // Default to cwd/clients if not found (will be created)
+  return path.join(process.cwd(), 'clients');
+}
+
+/**
+ * Discover all client directories
+ * @returns {Array<{id: string, path: string, hasConfig: boolean}>}
+ */
+function discoverClients() {
+  const clientsDir = getClientsDir();
+  const clients = [];
+
+  if (!fs.existsSync(clientsDir)) {
+    return clients;
+  }
+
+  try {
+    const entries = fs.readdirSync(clientsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
+        const clientPath = path.join(clientsDir, entry.name);
+        const configPath = path.join(clientPath, '.claude', 'CLAUDE.md');
+        const hasConfig = fs.existsSync(configPath);
+
+        clients.push({
+          id: entry.name,
+          path: clientPath,
+          hasConfig,
+        });
+      }
+    }
+  } catch (err) {
+    log(`[ClientManager] Error discovering clients: ${err.message}`);
+  }
+
+  return clients;
+}
+
+/**
+ * Parse a client CLAUDE.md file to extract configuration
+ * @param {string} configPath - Path to CLAUDE.md
+ * @returns {object|null} Parsed configuration
+ */
+function parseClientConfig(configPath) {
+  const content = readFile(configPath);
+  if (!content) return null;
+
+  const config = {
+    name: null,
+    complianceMode: 'standard',
+    zohoOrg: null,
+    clientId: null,
+    industry: null,
+    applications: [],
+    raw: content,
+  };
+
+  // Parse header - first line is usually "# [Client Name] - Configuration"
+  const headerMatch = content.match(/^#\s+(.+?)\s*[-–—]\s*Configuration/m);
+  if (headerMatch) {
+    config.name = headerMatch[1].trim();
+  }
+
+  // Parse structured fields
+  const patterns = {
+    complianceMode: /##\s*Compliance\s*Mode:\s*(\S+)/i,
+    zohoOrg: /##\s*Zoho\s*Organization:\s*(\S+)/i,
+    clientId: /##\s*Client\s*ID:\s*(\S+)/i,
+    industry: /##\s*Industry:\s*(\S+)/i,
+  };
+
+  for (const [key, pattern] of Object.entries(patterns)) {
+    const match = content.match(pattern);
+    if (match) {
+      config[key] = match[1].replace(/[[\]]/g, '').trim();
+    }
+  }
+
+  // Parse applications section
+  const appsMatch = content.match(/##\s*Applications\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+  if (appsMatch) {
+    const lines = appsMatch[1].split('\n').filter((l) => l.trim().startsWith('-'));
+    config.applications = lines.map((l) => l.replace(/^-\s*/, '').trim());
+  }
+
+  return config;
+}
+
+/**
+ * Load a client's .env.client file
+ * @param {string} clientPath - Path to client directory
+ * @returns {object} Parsed environment variables
+ */
+function loadClientEnv(clientPath) {
+  const envPath = path.join(clientPath, '.env.client');
+  const env = {};
+
+  if (!fs.existsSync(envPath)) {
+    return env;
+  }
+
+  const content = readFile(envPath);
+  if (!content) return env;
+
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Skip comments and empty lines
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex > 0) {
+      const key = trimmed.substring(0, eqIndex).trim();
+      const value = trimmed.substring(eqIndex + 1).trim();
+      env[key] = value;
+    }
+  }
+
+  return env;
+}
+
+/**
+ * Get recent git commits for a client
+ * @param {string} clientId - Client ID to filter commits
+ * @param {number} count - Number of commits to fetch
+ * @returns {Array<{hash: string, message: string}>}
+ */
+function getClientCommits(clientId, count = 5) {
+  const commits = [];
+
+  const result = runCommand(`git log --oneline -${count} --grep="[${clientId}]"`);
+  if (!result.success || !result.output) {
+    return commits;
+  }
+
+  const lines = result.output.split('\n').filter(Boolean);
+  for (const line of lines) {
+    const match = line.match(/^([a-f0-9]+)\s+(.+)$/);
+    if (match) {
+      commits.push({
+        hash: match[1],
+        message: match[2],
+      });
+    }
+  }
+
+  return commits;
+}
+
+/**
+ * Load full client context
+ * @param {string} clientId - Client identifier
+ * @returns {object|null} Full client context or null if not found
+ */
+function loadClient(clientId) {
+  const clientsDir = getClientsDir();
+  const clientPath = path.join(clientsDir, clientId);
+
+  if (!fs.existsSync(clientPath)) {
+    return null;
+  }
+
+  const configPath = path.join(clientPath, '.claude', 'CLAUDE.md');
+  const config = parseClientConfig(configPath);
+
+  if (!config) {
+    // Client directory exists but no config
+    return {
+      id: clientId,
+      path: clientPath,
+      name: clientId,
+      complianceMode: 'standard',
+      zohoOrg: null,
+      env: loadClientEnv(clientPath),
+      commits: getClientCommits(clientId),
+      hasConfig: false,
+    };
+  }
+
+  return {
+    id: clientId,
+    path: clientPath,
+    name: config.name || clientId,
+    complianceMode: config.complianceMode,
+    zohoOrg: config.zohoOrg,
+    clientId: config.clientId || clientId,
+    industry: config.industry,
+    applications: config.applications,
+    env: loadClientEnv(clientPath),
+    commits: getClientCommits(config.clientId || clientId),
+    hasConfig: true,
+    config,
+  };
+}
+
+/**
+ * Get compliance requirements for a mode
+ * @param {string} mode - Compliance mode
+ * @returns {Array<string>} List of requirements
+ */
+function getComplianceRequirements(mode) {
+  const requirements = {
+    hipaa: [
+      'ePHI field handling enabled',
+      'BAA documentation required',
+      'Audit log archival: 7 years',
+      'Session timeout: 15 minutes',
+      'All PHI fields must use [PHI] prefix',
+    ],
+    soc2: [
+      'Audit logging enabled',
+      'Change management required',
+      'Access controls documented',
+      'Annual compliance review',
+    ],
+    'pci-dss': [
+      'Use Zoho Checkout only for payments',
+      'Tokenization required for card data',
+      'SAQ-A compliance level',
+      'No PAN storage allowed',
+    ],
+    standard: ['Standard development practices', 'Code review required'],
+  };
+
+  return requirements[mode] || requirements.standard;
+}
+
+/**
+ * Set environment variables for a client context
+ * @param {object} client - Client context from loadClient
+ */
+function setClientEnvironment(client) {
+  // Set CloudStream-specific env vars
+  process.env.CLOUDSTREAM_CLIENT_ID = client.clientId || client.id;
+  process.env.CLOUDSTREAM_COMPLIANCE_MODE = client.complianceMode;
+
+  // Set env vars from .env.client
+  for (const [key, value] of Object.entries(client.env)) {
+    if (value) {
+      process.env[key] = value;
+    }
+  }
+}
+
+module.exports = {
+  getClientsDir,
+  discoverClients,
+  parseClientConfig,
+  loadClientEnv,
+  getClientCommits,
+  loadClient,
+  getComplianceRequirements,
+  setClientEnvironment,
+};

package/scripts/lib/command-matcher.js

@@ -0,0 +1,242 @@
+/**
+ * Command Matcher - Maps Detected Intents to Optimal Commands/Agents
+ *
+ * Takes classified intents from intent-classifier and maps them to
+ * the appropriate CloudStream Claude Code commands and agents.
+ *
+ * @module command-matcher
+ */
+
+/**
+ * Intent to command/agent mapping
+ *
+ * Structure:
+ * - command: The slash command to invoke
+ * - agent: Primary agent that handles this intent
+ * - agents: Array of agents (if multiple are needed)
+ * - model: Preferred model (opus for complex, sonnet for execution)
+ * - description: Human-readable description
+ */
+const INTENT_TO_COMMAND = {
+  PLANNING: {
+    command: '/plan',
+    agent: 'planner',
+    model: 'opus',
+    description: 'Strategic planner for feature design and architecture decisions',
+  },
+
+  TESTING: {
+    command: '/tdd',
+    agent: 'tdd-guide',
+    model: 'sonnet',
+    description: 'Test-driven development specialist enforcing 80%+ coverage',
+  },
+
+  REVIEW: {
+    command: '/code-review',
+    agent: 'code-reviewer',
+    agents: ['code-reviewer', 'security-reviewer'],
+    model: 'sonnet',
+    description: 'Comprehensive code and security review',
+  },
+
+  SECURITY: {
+    command: '/code-review', // Uses code-review with security focus
+    agent: 'security-reviewer',
+    model: 'opus',
+    description: 'Security vulnerability detection and remediation',
+  },
+
+  COMPLIANCE: {
+    command: '/compliance-check',
+    agent: 'compliance-auditor',
+    model: 'opus',
+    description: 'HIPAA/SOC2/PCI-DSS compliance audit',
+  },
+
+  ZOHO: {
+    command: '/zoho-scaffold',
+    agent: 'creator-architect',
+    agents: ['creator-architect', 'deluge-reviewer'],
+    model: 'opus',
+    description: 'Zoho Creator/Catalyst architecture and Deluge development',
+  },
+
+  DEPLOY: {
+    command: '/verify',
+    agent: 'catalyst-deployer',
+    model: 'sonnet',
+    description: 'Deployment verification and execution',
+  },
+
+  REFACTOR: {
+    command: '/refactor-clean',
+    agent: 'refactor-cleaner',
+    model: 'sonnet',
+    description: 'Dead code cleanup and consolidation',
+  },
+
+  DEBUG: {
+    command: '/build-fix',
+    agent: 'build-error-resolver',
+    model: 'sonnet',
+    description: 'Build and TypeScript error resolution',
+  },
+
+  // New intent mappings for full documentation alignment
+
+  LEARNING: {
+    command: '/learn',
+    agent: null,
+    model: 'sonnet',
+    description: 'Extract reusable patterns from current session',
+  },
+
+  SETUP: {
+    command: '/onboard',
+    agent: null,
+    model: 'sonnet',
+    description: 'Project setup and initialization wizard',
+  },
+
+  HANDOFF: {
+    command: '/handoff',
+    agent: 'doc-updater',
+    model: 'sonnet',
+    description: 'Client handoff documentation generation',
+  },
+
+  E2E: {
+    command: '/e2e',
+    agent: 'e2e-runner',
+    model: 'sonnet',
+    description: 'End-to-end test generation with Playwright',
+  },
+
+  DOCUMENTATION: {
+    command: '/update-docs',
+    agent: 'doc-updater',
+    model: 'sonnet',
+    description: 'Documentation generation and synchronization',
+  },
+};
+
+/**
+ * Match an intent to its optimal command/agent configuration
+ *
+ * @param {string} intent - The classified intent (e.g., 'PLANNING', 'TESTING')
+ * @returns {object|null} Command configuration or null if no match
+ */
+function matchCommand(intent) {
+  // Handle null/undefined/empty input
+  if (!intent || typeof intent !== 'string') {
+    return null;
+  }
+
+  // Normalize intent to uppercase
+  const normalizedIntent = intent.toUpperCase();
+
+  // UNKNOWN intent returns null
+  if (normalizedIntent === 'UNKNOWN') {
+    return null;
+  }
+
+  // Look up the mapping
+  const mapping = INTENT_TO_COMMAND[normalizedIntent];
+
+  if (!mapping) {
+    return null;
+  }
+
+  // Return a copy to prevent mutation
+  return {
+    command: mapping.command,
+    agent: mapping.agent,
+    agents: mapping.agents || [mapping.agent],
+    model: mapping.model,
+    description: mapping.description,
+    intent: normalizedIntent,
+  };
+}
+
+/**
+ * Format a complete command string with the user's task
+ *
+ * @param {string} intent - The classified intent
+ * @param {string} task - The user's task description
+ * @returns {string|null} Formatted command string or null if no match
+ */
+function formatCommand(intent, task = '') {
+  const mapping = matchCommand(intent);
+
+  if (!mapping) {
+    return null;
+  }
+
+  // Clean the task - remove any leading/trailing whitespace
+  const cleanTask = task.trim();
+
+  // Some commands don't need arguments
+  const commandsWithoutArgs = ['/verify', '/code-review', '/compliance-check'];
+
+  if (commandsWithoutArgs.includes(mapping.command) || !cleanTask) {
+    return mapping.command;
+  }
+
+  // Format the command with the task
+  return `${mapping.command} ${cleanTask}`;
+}
+
+/**
+ * Get all available command mappings
+ *
+ * @returns {object} All intent-to-command mappings
+ */
+function getAllMappings() {
+  return { ...INTENT_TO_COMMAND };
+}
+
+/**
+ * Check if an intent has a valid mapping
+ *
+ * @param {string} intent - The intent to check
+ * @returns {boolean} True if intent has a mapping
+ */
+function hasMapping(intent) {
+  if (!intent || typeof intent !== 'string') {
+    return false;
+  }
+  return intent.toUpperCase() in INTENT_TO_COMMAND;
+}
+
+/**
+ * Get commands that use Opus model (complex tasks)
+ *
+ * @returns {string[]} Array of intent names that use Opus
+ */
+function getOpusIntents() {
+  return Object.entries(INTENT_TO_COMMAND)
+    .filter(([_, config]) => config.model === 'opus')
+    .map(([intent]) => intent);
+}
+
+/**
+ * Get commands that use Sonnet model (execution tasks)
+ *
+ * @returns {string[]} Array of intent names that use Sonnet
+ */
+function getSonnetIntents() {
+  return Object.entries(INTENT_TO_COMMAND)
+    .filter(([_, config]) => config.model === 'sonnet')
+    .map(([intent]) => intent);
+}
+
+module.exports = {
+  matchCommand,
+  formatCommand,
+  getAllMappings,
+  hasMapping,
+  getOpusIntents,
+  getSonnetIntents,
+  INTENT_TO_COMMAND,
+};